CMS 3D CMS Logo
HLTLevel1GTSeed.cc
Go to the documentation of this file.
1 
17 // this class header
18 #include "HLTLevel1GTSeed.h"
19 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
20 
21 // system include files
22 #include <string>
23 #include <list>
24 #include <vector>
25 #include <algorithm>
26 
27 #include <iostream>
28 #include <sstream>
29 
30 // user include files
31 #include "DataFormats/Common/interface/Handle.h"
32 #include "DataFormats/Common/interface/Ref.h"
33 
34 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetupFwd.h"
35 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
36 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMapRecord.h"
37 
38 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMapFwd.h"
39 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMap.h"
40 
41 #include "DataFormats/L1GlobalTrigger/interface/L1GtLogicParser.h"
42 
43 #include "DataFormats/L1Trigger/interface/L1EmParticleFwd.h"
44 #include "DataFormats/L1Trigger/interface/L1JetParticleFwd.h"
45 #include "DataFormats/L1Trigger/interface/L1MuonParticleFwd.h"
46 #include "DataFormats/L1Trigger/interface/L1EtMissParticleFwd.h"
47 
48 #include "DataFormats/L1Trigger/interface/L1EmParticle.h"
49 #include "DataFormats/L1Trigger/interface/L1JetParticle.h"
50 #include "DataFormats/L1Trigger/interface/L1MuonParticle.h"
51 #include "DataFormats/L1Trigger/interface/L1EtMissParticle.h"
52 
53 #include "DataFormats/HLTReco/interface/TriggerFilterObjectWithRefs.h"
54 
55 #include "CondFormats/L1TObjects/interface/L1GtTriggerMenu.h"
56 #include "CondFormats/DataRecord/interface/L1GtTriggerMenuRcd.h"
57 
58 #include "CondFormats/L1TObjects/interface/L1GtTriggerMask.h"
59 #include "CondFormats/DataRecord/interface/L1GtTriggerMaskAlgoTrigRcd.h"
60 #include "CondFormats/DataRecord/interface/L1GtTriggerMaskTechTrigRcd.h"
61 
62 #include "CondFormats/L1TObjects/interface/L1GtCondition.h"
63 
64 #include "FWCore/ParameterSet/interface/ParameterSet.h"
65 #include "FWCore/Utilities/interface/InputTag.h"
66 
67 #include "FWCore/MessageLogger/interface/MessageLogger.h"
68 #include "FWCore/MessageLogger/interface/MessageDrop.h"
69 
70 #include "FWCore/Utilities/interface/Exception.h"
71 
72 #include "FWCore/Framework/interface/EventSetup.h"
73 #include "FWCore/Framework/interface/ESHandle.h"
74 
75 // constructors
76 HLTLevel1GTSeed::HLTLevel1GTSeed(const edm::ParameterSet& parSet) : HLTStreamFilter(parSet),
77  // initialize the cache
78  m_l1GtMenu( nullptr ),
79  m_l1GtMenuCacheID( 0ULL ),
80 
81  // seeding done via L1 trigger object maps, with objects that fired
82  m_l1UseL1TriggerObjectMaps(parSet.getParameter<bool> (
83  "L1UseL1TriggerObjectMaps")),
84 
85  // option used forL1UseL1TriggerObjectMaps = False only
86  m_l1NrBxInEvent(parSet.getParameter<int> (
87  "L1NrBxInEvent")),
88 
89  // seeding done via technical trigger bits, if value is "true"
90  m_l1TechTriggerSeeding(parSet.getParameter<bool> (
91  "L1TechTriggerSeeding")),
92 
93  // seeding uses algorithm aliases instead of algorithm names, if value is "true";
94  m_l1UseAliasesForSeeding(parSet.getParameter<bool> (
95  "L1UseAliasesForSeeding")),
96 
97  // logical expression for the required L1 algorithms
98  m_l1SeedsLogicalExpression(parSet.getParameter<std::string> (
99  "L1SeedsLogicalExpression")),
100 
101  // InputTag for the L1 Global Trigger DAQ readout record
102  m_l1GtReadoutRecordTag(parSet.getParameter<edm::InputTag> (
103  "L1GtReadoutRecordTag")),
104  m_l1GtReadoutRecordToken(consumes<L1GlobalTriggerReadoutRecord>(m_l1GtReadoutRecordTag)),
105 
106  // InputTag for L1 Global Trigger object maps
107  m_l1GtObjectMapTag(parSet.getParameter<edm::InputTag> (
108  "L1GtObjectMapTag")),
109  m_l1GtObjectMapToken(consumes<L1GlobalTriggerObjectMapRecord>(m_l1GtObjectMapTag)),
110 
111  // InputTag for L1 particle collections (except muon)
112  m_l1CollectionsTag(parSet.getParameter<edm::InputTag> (
113  "L1CollectionsTag")),
114 
115  // InputTag for L1 muon collection
116  m_l1MuonCollectionTag(parSet.getParameter<edm::InputTag> (
117  "L1MuonCollectionTag")),
118 
120  m_l1ExtraTag(edm::InputTag(m_l1CollectionsTag.label())),
121  m_l1MuonTag(edm::InputTag(m_l1MuonCollectionTag.label())),
122  m_l1MuonToken(consumes<l1extra::L1MuonParticleCollection>(m_l1MuonTag)),
123  m_l1IsoEGTag(edm::InputTag(m_l1CollectionsTag.label(), "Isolated")),
124  m_l1IsoEGToken(consumes<l1extra::L1EmParticleCollection>(m_l1IsoEGTag)),
125  m_l1NoIsoEGTag(edm::InputTag(m_l1CollectionsTag.label(),"NonIsolated")),
126  m_l1NoIsoEGToken(consumes<l1extra::L1EmParticleCollection>(m_l1NoIsoEGTag)),
127  m_l1CenJetTag(edm::InputTag(m_l1CollectionsTag.label(), "Central")),
128  m_l1CenJetToken(consumes<l1extra::L1JetParticleCollection>(m_l1CenJetTag)),
129  m_l1ForJetTag(edm::InputTag(m_l1CollectionsTag.label(), "Forward")),
130  m_l1ForJetToken(consumes<l1extra::L1JetParticleCollection>(m_l1ForJetTag)),
131  m_l1TauJetTag(edm::InputTag(m_l1CollectionsTag.label(), "Tau")),
132  m_l1TauJetToken(consumes<l1extra::L1JetParticleCollection>(m_l1TauJetTag)),
133  m_l1IsoTauJetTag(edm::InputTag(m_l1CollectionsTag.label(), "IsoTau")),
134  m_l1IsoTauJetToken(consumes<l1extra::L1JetParticleCollection>(m_l1IsoTauJetTag)),
135  m_l1EtMissMETTag(edm::InputTag(m_l1CollectionsTag.label(), "MET")),
136  m_l1EtMissMETToken(consumes<l1extra::L1EtMissParticleCollection>(m_l1EtMissMETTag)),
137  m_l1EtMissMHTTag(edm::InputTag(m_l1CollectionsTag.label(), "MHT")),
138  m_l1EtMissMHTToken(consumes<l1extra::L1EtMissParticleCollection>(m_l1EtMissMHTTag)),
139  m_l1GlobalDecision(false),
140  m_isDebugEnabled(edm::isDebugEnabled()) {
141 
142  if (m_l1SeedsLogicalExpression != "L1GlobalDecision") {
143 
144  // check also the logical expression - add/remove spaces if needed
145  m_l1AlgoLogicParser = L1GtLogicParser(m_l1SeedsLogicalExpression);
146 
147  // list of required algorithms for seeding
148  // dummy values for tokenNumber and tokenResult
149  m_l1AlgoSeeds.reserve((m_l1AlgoLogicParser.operandTokenVector()).size());
150  m_l1AlgoSeeds = m_l1AlgoLogicParser.expressionSeedsOperandList();
151  size_t l1AlgoSeedsSize = m_l1AlgoSeeds.size();
152 
153  //
154  m_l1AlgoSeedsRpn.reserve(l1AlgoSeedsSize);
155  m_l1AlgoSeedsObjType.reserve(l1AlgoSeedsSize);
156  } else {
157  m_l1GlobalDecision = true;
158  }
159 
160  // for seeding via technical triggers, convert the "name" to tokenNumber
161  // (seeding via bit numbers)
162  if (m_l1TechTriggerSeeding) {
163  convertStringToBitNumber();
164  }
165 
166  LogDebug("HLTLevel1GTSeed") << "\n"
167  << "L1 Seeding using L1 trigger object maps: "
168  << m_l1UseL1TriggerObjectMaps << "\n"
169  << " if false: seeding with L1Extra\n"
170  << "Number of BxInEvent when seeding with L1Extra: "
171  << m_l1NrBxInEvent << "\n"
172  << " aka w/o object maps\n " << "\n"
173  << "L1 Seeding via Technical Triggers: "
174  << m_l1TechTriggerSeeding << "\n"
175  << "L1 Seeding uses algorithm aliases: "
176  << m_l1UseAliasesForSeeding << "\n"
177  << "L1 Seeds Logical Expression: " << "\n "
178  << m_l1SeedsLogicalExpression << "\n"
179  << "Input tag for L1 GT DAQ record: "
180  << m_l1GtReadoutRecordTag << " \n"
181  << "Input tag for L1 GT object map record: "
182  << m_l1GtObjectMapTag << " \n"
183  << "Input tag for L1 extra collections: "
184  << m_l1CollectionsTag << " \n"
185  << "Input tag for L1 muon collections: "
186  << m_l1MuonCollectionTag << " \n" << std::endl;
187 }
188 
189 // destructor
190 HLTLevel1GTSeed::~HLTLevel1GTSeed() {
191  // empty now
192 }
193 
194 // member functions
195 
196 void
197 HLTLevel1GTSeed::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
198  edm::ParameterSetDescription desc;
199  makeHLTFilterDescription(desc);
200 
201  // # default: true
202  // # seeding done via L1 trigger object maps, with objects that fired
203  // # only objects from the central BxInEvent (L1A) are used
204  // # if false:
205  // # seeding is done ignoring if a L1 object fired or not,
206  // # adding all L1EXtra objects corresponding to the object types
207  // # used in all conditions from the algorithms in logical expression
208  // # for a given number of BxInEvent
209  desc.add<bool>("L1UseL1TriggerObjectMaps",true);
210 
211  // # option used forL1UseL1TriggerObjectMaps = False only
212  // # number of BxInEvent: 1: L1A=0; 3: -1, L1A=0, 1; 5: -2, -1, L1A=0, 1, 2
213  desc.add<int>("L1NrBxInEvent",3);
214 
215  // # seeding done via technical trigger bits, if value is "true";
216  // # default: false (seeding via physics algorithms)
217  desc.add<bool>("L1TechTriggerSeeding",false);
218 
219  // # seeding done with aliases for physics algorithms
220  desc.add<bool>("L1UseAliasesForSeeding",true);
221 
222  // # logical expression for the required L1 algorithms;
223  // # the algorithms are specified by name
224  // # allowed operators: "AND", "OR", "NOT", "(", ")"
225  // #
226  // # by convention, "L1GlobalDecision" logical expression means global decision
227  desc.add<std::string>("L1SeedsLogicalExpression","");
228 
229  // # InputTag for the L1 Global Trigger DAQ readout record
230  // # GT Emulator = gtDigis
231  // # GT Unpacker = l1GtUnpack
232  // #
233  // # cloned GT unpacker in HLT = gtDigis
234  desc.add<edm::InputTag>("L1GtReadoutRecordTag",edm::InputTag("gtDigis"));
235 
236  // # InputTag for L1 Global Trigger object maps
237  // # only the emulator produces the object maps
238  // # GT Emulator = gtDigis
239  // #
240  // # cloned GT emulator in HLT = l1GtObjectMap
241  desc.add<edm::InputTag>("L1GtObjectMapTag",edm::InputTag("l1GtObjectMap"));
242 
243  // # InputTag for L1 particle collections (except muon)
244  // # L1 Extra = l1extraParticles
245  desc.add<edm::InputTag>("L1CollectionsTag",edm::InputTag("l1extraParticles"));
246 
247  // # InputTag for L1 muon collection
248  // # L1 Extra = l1extraParticles
249  desc.add<edm::InputTag>("L1MuonCollectionTag",edm::InputTag("l1extraParticles"));
250 
251  descriptions.add("hltLevel1GTSeed", desc);
252 }
253 
254 bool HLTLevel1GTSeed::hltFilter(edm::Event& iEvent, const edm::EventSetup& evSetup, trigger::TriggerFilterObjectWithRefs & filterproduct) {
255 
256  // all HLT filters must create and fill a HLT filter object,
257  // recording any reconstructed physics objects satisfying
258  // this HLT filter, and place it in the event.
259 
260  // the filter object
261  if (saveTags()) {
262  filterproduct.addCollectionTag(m_l1MuonTag);
263  filterproduct.addCollectionTag(m_l1ExtraTag);
264  filterproduct.addCollectionTag(m_l1IsoEGTag);
265  filterproduct.addCollectionTag(m_l1NoIsoEGTag);
266  filterproduct.addCollectionTag(m_l1CenJetTag);
267  filterproduct.addCollectionTag(m_l1ForJetTag);
268  filterproduct.addCollectionTag(m_l1TauJetTag);
269  filterproduct.addCollectionTag(m_l1IsoTauJetTag);
270  filterproduct.addCollectionTag(m_l1EtMissMETTag);
271  filterproduct.addCollectionTag(m_l1EtMissMHTTag);
272  }
273 
274  // get the trigger mask from the EventSetup
275  edm::ESHandle<L1GtTriggerMask> l1GtTmAlgo;
276  evSetup.get<L1GtTriggerMaskAlgoTrigRcd>().get(l1GtTmAlgo);
277 
278  // get L1GlobalTriggerReadoutRecord and GT decision
279  edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecord;
280  iEvent.getByToken(m_l1GtReadoutRecordToken, gtReadoutRecord);
281  const L1GlobalTriggerReadoutRecord* gtReadoutRecordPtr =
282  gtReadoutRecord.product();
283 
284  if (!gtReadoutRecord.isValid()) {
285  edm::LogWarning("HLTLevel1GTSeed")
286  << "\nWarning: L1GlobalTriggerReadoutRecord with input tag "
287  << m_l1GtReadoutRecordTag
288  << "\nrequested in configuration, but not found in the event."
289  << std::endl;
290  return false;
291  }
292 
293  //
294  boost::uint16_t gtFinalOR = gtReadoutRecord->finalOR();
295  int physicsDaqPartition = 0;
296  bool gtDecision =
297  static_cast<bool> (gtFinalOR & (1 << physicsDaqPartition));
298 
299  // GT global decision "false" possible only when running on MC or on random triggers
300  if (!gtDecision) {
301 
302  return false;
303 
304  } else {
305 
306  // by convention, "L1GlobalDecision" logical expression means global decision
307  if (m_l1GlobalDecision) {
308 
309  // return the full L1GlobalTriggerObjectMapRecord in filter format FIXME
310  return true;
311 
312  }
313 
314  }
315 
316  // seeding done via technical trigger bits
317  if (m_l1TechTriggerSeeding) {
318 
319  // get the technical trigger mask from the EventSetup
320  edm::ESHandle<L1GtTriggerMask> l1GtTmTech;
321  evSetup.get<L1GtTriggerMaskTechTrigRcd>().get(l1GtTmTech);
322 
323  // get Global Trigger technical trigger word, update the tokenResult members
324  // from m_l1AlgoLogicParser and get the result for the logical expression
325  const std::vector<bool>& gtTechTrigWord = gtReadoutRecord->technicalTriggerWord();
326  updateAlgoLogicParser(gtTechTrigWord, l1GtTmTech->gtTriggerMask(), physicsDaqPartition);
327 
328  // always empty filter - GT not aware of objects for technical triggers
329  bool seedsResult = m_l1AlgoLogicParser.expressionResult();
330 
331  if (seedsResult) {
332  return true;
333  } else {
334  return false;
335  }
336 
337  }
338 
339  // seeding via physics algorithms
340 
341  // get / update the trigger menu from the EventSetup
342  // local cache & check on cacheIdentifier
343 
344  unsigned long long l1GtMenuCacheID =
345  evSetup.get<L1GtTriggerMenuRcd>().cacheIdentifier();
346 
347  if (m_l1GtMenuCacheID != l1GtMenuCacheID) {
348 
349  edm::ESHandle<L1GtTriggerMenu> l1GtMenu;
350  evSetup.get<L1GtTriggerMenuRcd>().get(l1GtMenu);
351  m_l1GtMenu = l1GtMenu.product();
352  m_l1GtMenuCacheID = l1GtMenuCacheID;
353 
354  const AlgorithmMap& algorithmMap = l1GtMenu->gtAlgorithmMap();
355  const AlgorithmMap& algorithmAliasMap = l1GtMenu->gtAlgorithmAliasMap();
356 
357  LogTrace("HLTLevel1GTSeed") << "\n L1 trigger menu "
358  << l1GtMenu->gtTriggerMenuInterface()
359  << "\n Number of algorithm names: "
360  << (algorithmMap.size())
361  << "\n Number of algorithm aliases: "
362  << (algorithmAliasMap.size()) << "\n" << std::endl;
363 
364  // update also the tokenNumber members (holding the bit numbers) from m_l1AlgoLogicParser
365  if (m_l1UseAliasesForSeeding) {
366  updateAlgoLogicParser(m_l1GtMenu, algorithmAliasMap);
367  } else {
368  updateAlgoLogicParser(m_l1GtMenu, algorithmMap);
369  }
370  }
371 
372  // FinalOR is true, it was tested before
373  if (m_l1UseL1TriggerObjectMaps) {
374  if (not seedsL1TriggerObjectMaps(iEvent, filterproduct, l1GtTmAlgo.product(), gtReadoutRecordPtr, physicsDaqPartition))
375  return false;
376  } else {
377  if (not seedsL1Extra(iEvent, filterproduct))
378  return false;
379  }
380 
381  if (m_isDebugEnabled) {
382  dumpTriggerFilterObjectWithRefs(filterproduct);
383  }
384 
385  return true;
386 
387 }
388 
389 const std::vector<L1GtObject>* HLTLevel1GTSeed::objectTypeVec(const int chipNr,
390  const std::string& cndName) const {
391 
392  const ConditionMap& conditionMap =
393  (m_l1GtMenu->gtConditionMap()).at(chipNr);
394 
395  auto itCond = conditionMap.find(cndName);
396  if (itCond != conditionMap.end())
397  return (&((itCond->second)->objectType()));
398 
399  // this should never be happen, all conditions are in the maps
400  throw cms::Exception("FailModule") << "\nCondition " << cndName << " not found in the condition map" << " for chip number " << chipNr;
401 }
402 
403 // for a new L1 Trigger menu, update the tokenNumber (holding the bit numbers)
404 // from m_l1AlgoLogicParser and from m_l1AlgoSeeds, and fill the m_l1AlgoSeedsRpn vector
405 void HLTLevel1GTSeed::updateAlgoLogicParser(const L1GtTriggerMenu* l1GtMenu, const AlgorithmMap& algorithmMap) {
406 
407  std::vector<L1GtLogicParser::OperandToken>& algOpTokenVector = m_l1AlgoLogicParser.operandTokenVector();
408 
409  size_t jSeed = 0;
410  size_t l1AlgoSeedsSize = m_l1AlgoSeeds.size();
411 
412  // clear the content from the previous menu for the vector of RPN vectors m_l1AlgoSeedsRpn
413  // and for the the vector of object-type vectors m_l1AlgoSeedsObjType
414  m_l1AlgoSeedsRpn.clear();
415  m_l1AlgoSeedsObjType.clear();
416 
417  //
418 
419  for (auto & i : algOpTokenVector) {
420 
421  auto itAlgo = algorithmMap.find(i.tokenName);
422  if (itAlgo != algorithmMap.end()) {
423 
424  int bitNr = (itAlgo->second).algoBitNumber();
425  int chipNr = (itAlgo->second).algoChipNumber();
426 
427  i.tokenNumber = bitNr;
428 
429  // algOpTokenVector and m_l1AlgoSeeds must have the same ordering
430  // of the algorithms
431  if (jSeed < l1AlgoSeedsSize) {
432 
433  //LogTrace("HLTLevel1GTSeed") << "(m_l1AlgoSeeds[jSeed]).tokenName: "
434  // << (m_l1AlgoSeeds[jSeed]).tokenName
435  // << std::endl;
436 
437  if ((m_l1AlgoSeeds[jSeed]).tokenName
438  == i.tokenName) {
439 
440  (m_l1AlgoSeeds[jSeed]).tokenNumber = bitNr;
441 
442  const std::vector<L1GtLogicParser::TokenRPN>& aRpnVector =
443  (itAlgo->second).algoRpnVector();
444  size_t aRpnVectorSize = aRpnVector.size();
445 
446  m_l1AlgoSeedsRpn.push_back(&aRpnVector);
447 
448  // loop over RpnVector to fill for each condition the object type
449  std::vector<const std::vector<L1GtObject>*> tmpObjTypeVec;
450  tmpObjTypeVec.reserve(aRpnVectorSize);
451 
452  for (size_t opI = 0; opI < aRpnVectorSize; ++opI) {
453 
454  std::string cName = (aRpnVector[opI]).operand;
455 
456  if (!cName.empty()) {
457 
458  tmpObjTypeVec.push_back(
459  objectTypeVec(chipNr, cName));
460 
461  //LogTrace("HLTLevel1GTSeed")
462  // << " Push object vector for condition: " << cName
463  // << std::endl;
464  }
465  }
466 
467  m_l1AlgoSeedsObjType.push_back(tmpObjTypeVec);
468 
469  jSeed++;
470  }
471  }
472  } else {
473 
474  throw cms::Exception("FailModule") << "\nAlgorithm "
475  << i.tokenName
476  << ", requested as seed by a HLT path, not found in the L1 trigger menu\n "
477  << l1GtMenu->gtTriggerMenuName()
478  << "\nIncompatible L1 and HLT menus.\n" << std::endl;
479 
480  }
481 
482  }
483 
484  //
485  if (m_isDebugEnabled) {
486  bool newMenu = true;
487  debugPrint(newMenu);
488  }
489 
490 }
491 
492 // update the tokenResult members from m_l1AlgoLogicParser
493 // for a new event
494 void HLTLevel1GTSeed::updateAlgoLogicParser(const std::vector<bool>& gtWord,
495  const std::vector<unsigned int>& triggerMask,
496  const int physicsDaqPartition) {
497 
498  std::vector<L1GtLogicParser::OperandToken>& algOpTokenVector =
499  m_l1AlgoLogicParser.operandTokenVector();
500 
501  for (auto & i : algOpTokenVector) {
502  int iBit = i.tokenNumber;
503  bool iResult = gtWord.at(iBit);
504 
505  int triggerMaskBit = triggerMask[iBit] & (1 << physicsDaqPartition);
506  //LogTrace("HLTLevel1GTSeed")
507  //<< "\nTrigger bit: " << iBit
508  //<< " mask = " << triggerMaskBit
509  //<< " DAQ partition " << physicsDaqPartition
510  //<< std::endl;
511 
512  if (triggerMaskBit) {
513  iResult = false;
514 
515  //LogTrace("HLTLevel1GTSeed")
516  //<< "\nMasked trigger: " << iBit << ". Result set to false\n"
517  //<< std::endl;
518  }
519 
520  i.tokenResult = iResult;
521 
522  }
523 
524  for (auto & m_l1AlgoSeed : m_l1AlgoSeeds) {
525  int iBit = m_l1AlgoSeed.tokenNumber;
526  bool iResult = gtWord.at(iBit);
527 
528  int triggerMaskBit = triggerMask[iBit] & (1 << physicsDaqPartition);
529  //LogTrace("HLTLevel1GTSeed")
530  //<< "\nTrigger bit: " << iBit
531  //<< " mask = " << triggerMaskBit
532  //<< " DAQ partition " << physicsDaqPartition
533  //<< std::endl;
534 
535  if (triggerMaskBit) {
536  iResult = false;
537 
538  //LogTrace("HLTLevel1GTSeed")
539  //<< "\nMasked trigger: " << iBit << ". Result set to false\n"
540  //<< std::endl;
541  }
542 
543  m_l1AlgoSeed.tokenResult = iResult;
544 
545  }
546 
547  if (m_isDebugEnabled) {
548  bool newMenu = false;
549  debugPrint(newMenu);
550  }
551 
552 }
553 
554 // for seeding via technical triggers, convert the "name" to tokenNumber
555 // (seeding via bit numbers) - done once in constructor
556 void HLTLevel1GTSeed::convertStringToBitNumber() {
557 
558  std::vector<L1GtLogicParser::OperandToken> & algOpTokenVector =
559  m_l1AlgoLogicParser.operandTokenVector();
560 
561  for (auto & i : algOpTokenVector) {
562 
563  std::string bitString = i.tokenName;
564  std::istringstream bitStream(bitString);
565  int bitInt;
566 
567  if ((bitStream >> bitInt).fail()) {
568 
569  throw cms::Exception("FailModule")
570  << "\nL1 Seeds Logical Expression: = '"
571  << m_l1SeedsLogicalExpression << "'"
572  << "\n Conversion to integer failed for " << bitString
573  << std::endl;
574  }
575 
576  i.tokenNumber = bitInt;
577 
578  }
579 
580  for (auto & m_l1AlgoSeed : m_l1AlgoSeeds) {
581 
582  std::string bitString = m_l1AlgoSeed.tokenName;
583  std::istringstream bitStream(bitString);
584  int bitInt;
585 
586  if ((bitStream >> bitInt).fail()) {
587 
588  throw cms::Exception("FailModule")
589  << "\nL1 Seeds Logical Expression: = '"
590  << m_l1SeedsLogicalExpression << "'"
591  << "\n Conversion to integer failed for " << bitString
592  << std::endl;
593  }
594 
595  m_l1AlgoSeed.tokenNumber = bitInt;
596  }
597 
598 }
599 
600 // debug print grouped in a single function
601 // can be called for a new menu (bool "true") or for a new event
602 void HLTLevel1GTSeed::debugPrint(bool newMenu) const
603 {
604 
605  if (m_l1TechTriggerSeeding) {
606  LogDebug("HLTLevel1GTSeed")
607  << "\n\nupdateAlgoLogicParser: seeding via technical trigger"
608  << "\n update event quantities." << std::endl;
609 
610  } else {
611 
612  if (newMenu) {
613  LogDebug("HLTLevel1GTSeed")
614  << "\n\nupdateAlgoLogicParser: L1 trigger menu changed to "
615  << m_l1GtMenu->gtTriggerMenuName() << std::endl;
616  } else {
617  LogDebug("HLTLevel1GTSeed")
618  << "\n\nupdateAlgoLogicParser: L1 trigger menu unchanged ("
619  << m_l1GtMenu->gtTriggerMenuName()
620  << ")\n update event quantities." << std::endl;
621  }
622  }
623 
624  std::vector<L1GtLogicParser::OperandToken> const & algOpTokenVector =
625  m_l1AlgoLogicParser.operandTokenVector();
626 
627  LogTrace("HLTLevel1GTSeed")
628  << "\n\nupdateAlgoLogicParser: algOpTokenVector.size() = "
629  << algOpTokenVector.size() << std::endl;
630 
631  for (auto const & i : algOpTokenVector) {
632 
633  LogTrace("HLTLevel1GTSeed") << " " << std::setw(5)
634  << i.tokenNumber << "\t" << std::setw(25)
635  << i.tokenName << "\t"
636  << i.tokenResult << std::endl;
637  }
638 
639  LogTrace("HLTLevel1GTSeed") << std::endl;
640 
641  LogTrace("HLTLevel1GTSeed")
642  << "\nupdateAlgoLogicParser: m_l1AlgoSeeds.size() = "
643  << m_l1AlgoSeeds.size() << std::endl;
644 
645  for (auto const & m_l1AlgoSeed : m_l1AlgoSeeds) {
646 
647  LogTrace("HLTLevel1GTSeed") << " " << std::setw(5)
648  << m_l1AlgoSeed.tokenNumber << "\t" << std::setw(25)
649  << m_l1AlgoSeed.tokenName << "\t"
650  << m_l1AlgoSeed.tokenResult << std::endl;
651  }
652 
653  LogTrace("HLTLevel1GTSeed") << std::endl;
654 
655  if (!newMenu) {
656  return;
657  }
658 
659  LogTrace("HLTLevel1GTSeed")
660  << "\nupdateAlgoLogicParser: m_l1AlgoSeedsRpn.size() = "
661  << m_l1AlgoSeedsRpn.size() << std::endl;
662 
663  for (auto i : m_l1AlgoSeedsRpn) {
664 
665  LogTrace("HLTLevel1GTSeed") << " Rpn vector size: "
666  << i->size() << std::endl;
667 
668  for (size_t j = 0; j < i->size(); ++j) {
669 
670  LogTrace("HLTLevel1GTSeed") << " ( "
671  << (*i)[j].operation << ", "
672  << (*i)[j].operand << " )" << std::endl;
673 
674  }
675  }
676 
677  LogTrace("HLTLevel1GTSeed") << std::endl;
678 
679  LogTrace("HLTLevel1GTSeed") << "\nupdateAlgoLogicParser: "
680  << "algorithms in seed expression: m_l1AlgoSeedsObjType.size() = "
681  << m_l1AlgoSeedsObjType.size() << std::endl;
682 
683  for (auto const & i : m_l1AlgoSeedsObjType) {
684 
685  LogTrace("HLTLevel1GTSeed")
686  << " Conditions for an algorithm: vector size: "
687  << i.size() << std::endl;
688 
689  for (size_t j = 0; j < i.size(); ++j) {
690 
691  LogTrace("HLTLevel1GTSeed")
692  << " Condition object type vector: size: "
693  << (i[j])->size() << std::endl;
694 
695  for (size_t k = 0; k < (i[j])->size(); ++k) {
696 
697  L1GtObject obj = (*(i[j]))[k];
698  LogTrace("HLTLevel1GTSeed") << " " << obj << " ";
699 
700  }
701 
702  LogTrace("HLTLevel1GTSeed") << std::endl;
703 
704  }
705  }
706 
707  LogTrace("HLTLevel1GTSeed") << std::endl;
708 
709 }
710 
711 
712 // seeding is done via L1 trigger object maps, considering the objects which fired in L1
713 bool HLTLevel1GTSeed::seedsL1TriggerObjectMaps(edm::Event& iEvent,
714  trigger::TriggerFilterObjectWithRefs & filterproduct,
715  const L1GtTriggerMask * l1GtTmAlgo,
716  const L1GlobalTriggerReadoutRecord* gtReadoutRecordPtr,
717  const int physicsDaqPartition) {
718 
719  // get Global Trigger decision word, update the tokenResult members
720  // from m_l1AlgoLogicParser and get the result for the logical expression
721  const std::vector<bool>& gtDecisionWord = gtReadoutRecordPtr->decisionWord();
722  updateAlgoLogicParser(gtDecisionWord, l1GtTmAlgo->gtTriggerMask(), physicsDaqPartition);
723 
724  bool seedsResult = m_l1AlgoLogicParser.expressionResult();
725 
726  if (m_isDebugEnabled ) {
727  // define an output stream to print into
728  // it can then be directed to whatever log level is desired
729  std::ostringstream myCoutStream;
730  gtReadoutRecordPtr->printGtDecision(myCoutStream);
731 
732  LogTrace("HLTLevel1GTSeed")
733  << myCoutStream.str()
734  << "\nHLTLevel1GTSeed::hltFilter "
735  << "\nLogical expression (names) = '" << m_l1SeedsLogicalExpression << "'"
736  << "\n Result for logical expression: " << seedsResult << "\n"
737  << std::endl;
738  }
739 
740  // the evaluation of the logical expression is false - skip event
741  if ( !seedsResult) {
742 
743  return false;
744 
745  }
746 
747  // define index lists for all particle types
748 
749  std::list<int> listMuon;
750 
751  std::list<int> listIsoEG;
752  std::list<int> listNoIsoEG;
753 
754  std::list<int> listCenJet;
755  std::list<int> listForJet;
756  std::list<int> listTauJet;
757  std::list<int> listIsoTauJet;
758 
759  std::list<int> listETM;
760  std::list<int> listETT;
761  std::list<int> listHTT;
762  std::list<int> listHTM;
763 
764  std::list<int> listJetCounts;
765 
766  // get handle to object maps (one object map per algorithm)
767  edm::Handle<L1GlobalTriggerObjectMapRecord> gtObjectMapRecord;
768  iEvent.getByToken(m_l1GtObjectMapToken, gtObjectMapRecord);
769 
770  if (!gtObjectMapRecord.isValid()) {
771  edm::LogWarning("HLTLevel1GTSeed")
772  << "\nWarning: L1GlobalTriggerObjectMapRecord with input tag "
773  << m_l1GtReadoutRecordTag
774  << "\nrequested in configuration, but not found in the event." << std::endl;
775 
776  return false;
777  }
778 
779  // TODO check that the L1GlobalTriggerObjectMapRecord corresponds to the same menu as
780  // the menu run by HLTLevel1GTSeed
781  // true normally online (they are run in the same job)
782  // can be false offline, when re-running HLT without re-running the object map producer
783 
784  // loop over the list of required algorithms for seeding
785  int iAlgo = -1;
786 
787  for (std::vector<L1GtLogicParser::OperandToken>::const_iterator
788  itSeed = m_l1AlgoSeeds.begin(); itSeed != m_l1AlgoSeeds.end(); ++itSeed) {
789 
790  //
791  iAlgo++;
792  //
793  int algBit = (*itSeed).tokenNumber;
794  std::string algName = (*itSeed).tokenName;
795  bool algResult = (*itSeed).tokenResult;
796 
797  LogTrace("HLTLevel1GTSeed")
798  << "\nHLTLevel1GTSeed::hltFilter "
799  << "\n Algorithm " << algName << " with bit number " << algBit
800  << " in the object map seed list"
801  << "\n Algorithm result = " << algResult << "\n"
802  << std::endl;
803 
804  // algorithm result is false - no seeds
805  if ( !algResult) {
806  continue;
807  }
808 
809  // algorithm result is true - get object map, loop over conditions in the algorithm
810  const L1GlobalTriggerObjectMap* objMap = gtObjectMapRecord->getObjectMap(algBit);
811 
812  if (objMap == nullptr) {
813  edm::LogWarning("HLTLevel1GTSeed")
814  << "\nWarning: L1GlobalTriggerObjectMap for algorithm " << algName
815  << " (bit number " << algBit << ") does not exist.\nReturn false.\n"
816  << std::endl;
817  return false;
818  }
819 
820  const std::vector<L1GtLogicParser::OperandToken>& opTokenVecObjMap =
821  objMap->operandTokenVector();
822 
823  const std::vector<L1GtLogicParser::TokenRPN>& algoSeedsRpn =
824  * ( m_l1AlgoSeedsRpn.at(iAlgo) );
825 
826  const std::vector<const std::vector<L1GtObject>*>& algoSeedsObjTypeVec =
827  m_l1AlgoSeedsObjType[iAlgo];
828 
829  //
830  L1GtLogicParser logicParserConditions(algoSeedsRpn, opTokenVecObjMap);
831 
832  // get list of required conditions for seeding - loop over
833  std::vector<L1GtLogicParser::OperandToken> condSeeds =
834  logicParserConditions.expressionSeedsOperandList();
835 
836  if (m_isDebugEnabled ) {
837 
838  LogTrace("HLTLevel1GTSeed")
839  << "\n HLTLevel1GTSeed::hltFilter "
840  << "\n condSeeds.size() = "
841  << condSeeds.size()
842  << std::endl;
843 
844  for (auto & condSeed : condSeeds) {
845 
846  LogTrace("HLTLevel1GTSeed")
847  << " " << std::setw(5) << condSeed.tokenNumber << "\t"
848  << std::setw(25) << condSeed.tokenName << "\t"
849  << condSeed.tokenResult
850  << std::endl;
851  }
852 
853  LogTrace("HLTLevel1GTSeed")
854  << std::endl;
855  }
856 
857  for (std::vector<L1GtLogicParser::OperandToken>::const_iterator
858  itCond = condSeeds.begin(); itCond != condSeeds.end(); itCond++) {
859 
860  std::string cndName = (*itCond).tokenName;
861  int cndNumber = (*itCond).tokenNumber;
862  bool cndResult = (*itCond).tokenResult;
863 
864  const std::vector<L1GtObject>* cndObjTypeVec = algoSeedsObjTypeVec.at(cndNumber);
865 
866  //LogTrace("HLTLevel1GTSeed")
867  // << "\n HLTLevel1GTSeed::hltFilter "
868  // << "\n Condition " << cndName << " with number " << cndNumber
869  // << " in the seed list"
870  // << "\n Condition result = " << cndResult << "\n"
871  // << std::endl;
872 
873  if ( !cndResult) {
874  continue;
875  }
876 
877  // loop over combinations for a given condition
878 
879  const CombinationsInCond* cndComb = objMap->getCombinationsInCond(cndNumber);
880 
881  for (auto const & itComb : (*cndComb)) {
882 
883  // loop over objects in a combination for a given condition
884  int iObj = 0;
885  for (auto
886  itObject = itComb.begin(); itObject != itComb.end(); itObject++) {
887 
888  // get object type and push indices on the list
889  const L1GtObject objTypeVal = (*cndObjTypeVec).at(iObj);
890 
891  //LogTrace("HLTLevel1GTSeed")
892  // << "\n HLTLevel1GTSeed::hltFilter "
893  // << "\n Add object of type " << objTypeVal
894  // << " and index " << (*itObject) << " to the seed list."
895  // << std::endl;
896 
897  switch (objTypeVal) {
898  case Mu: {
899  listMuon.push_back(*itObject);
900  }
901 
902  break;
903  case NoIsoEG: {
904  listNoIsoEG.push_back(*itObject);
905  }
906 
907  break;
908  case IsoEG: {
909  listIsoEG.push_back(*itObject);
910  }
911 
912  break;
913  case CenJet: {
914  listCenJet.push_back(*itObject);
915  }
916 
917  break;
918  case ForJet: {
919  listForJet.push_back(*itObject);
920  }
921 
922  break;
923  case TauJet: {
924  listTauJet.push_back(*itObject);
925  }
926 
927  break;
928  case HfRingEtSums: {
929  // Special treatment needed to match HFRingEtSums index (Ind) with corresponding l1extra item
930  // Same ranking (Et) is assumed for both HFRingEtSums indexes and items in l1extra IsoTau collection
931  // Each HFRingEtSums_IndN corresponds with one object (with (*itObject)=0);
932  // its index (hfInd) encodded by parsing algorithm name
933  int hfInd = (*itObject);
934  if(cndName.find("Ind0")!=std::string::npos)
935  hfInd = 0;
936  else if(cndName.find("Ind1")!=std::string::npos)
937  hfInd = 1;
938  else if(cndName.find("Ind2")!=std::string::npos)
939  hfInd = 2;
940  else if(cndName.find("Ind3")!=std::string::npos)
941  hfInd = 3;
942  listIsoTauJet.push_back(hfInd);
943  }
944 
945  break;
946  case ETM: {
947  listETM.push_back(*itObject);
948 
949  }
950 
951  break;
952  case ETT: {
953  listETT.push_back(*itObject);
954 
955  }
956 
957  break;
958  case HTT: {
959  listHTT.push_back(*itObject);
960 
961  }
962 
963  break;
964  case HTM: {
965  listHTM.push_back(*itObject);
966 
967  }
968 
969  break;
970  case JetCounts: {
971  listJetCounts.push_back(*itObject);
972  }
973 
974  break;
975  default: {
976  // should not arrive here
977 
978  LogDebug("HLTLevel1GTSeed")
979  << "\n HLTLevel1GTSeed::hltFilter "
980  << "\n Unknown object of type " << objTypeVal
981  << " and index " << (*itObject) << " in the seed list."
982  << std::endl;
983  }
984  break;
985  }
986 
987  iObj++;
988 
989  }
990 
991  }
992 
993  }
994 
995  }
996 
997  // eliminate duplicates
998 
999  listMuon.sort();
1000  listMuon.unique();
1001 
1002  listIsoEG.sort();
1003  listIsoEG.unique();
1004 
1005  listNoIsoEG.sort();
1006  listNoIsoEG.unique();
1007 
1008  listCenJet.sort();
1009  listCenJet.unique();
1010 
1011  listForJet.sort();
1012  listForJet.unique();
1013 
1014  listTauJet.sort();
1015  listTauJet.unique();
1016 
1017  listIsoTauJet.sort();
1018  listIsoTauJet.unique();
1019 
1020  listETM.sort();
1021  listETM.unique();
1022 
1023  listETT.sort();
1024  listETT.unique();
1025 
1026  listHTT.sort();
1027  listHTT.unique();
1028 
1029  listHTM.sort();
1030  listHTM.unique();
1031 
1032  listJetCounts.sort();
1033  listJetCounts.unique();
1034 
1035  //
1036  // record the L1 physics objects in the HLT filterproduct
1037  //
1038 
1039  // muon
1040  if (!listMuon.empty()) {
1041 
1042  edm::Handle<l1extra::L1MuonParticleCollection> l1Muon;
1043  iEvent.getByToken(m_l1MuonToken, l1Muon);
1044 
1045  if (!l1Muon.isValid()) {
1046  edm::LogWarning("HLTLevel1GTSeed")
1047  << "\nWarning: L1MuonParticleCollection with input tag " << m_l1MuonTag
1048  << "\nrequested in configuration, but not found in the event."
1049  << "\nNo muon added to filterproduct." << std::endl;
1050 
1051  } else {
1052 
1053  for (std::list<int>::const_iterator itObj = listMuon.begin(); itObj != listMuon.end(); ++itObj) {
1054 
1055  filterproduct.addObject(trigger::TriggerL1Mu, l1extra::L1MuonParticleRef(
1056  l1Muon, *itObj));
1057 
1058  }
1059  }
1060 
1061  }
1062 
1063  // EG (isolated)
1064  if (!listIsoEG.empty()) {
1065  edm::Handle<l1extra::L1EmParticleCollection> l1IsoEG;
1066  iEvent.getByToken(m_l1IsoEGToken, l1IsoEG);
1067 
1068  if (!l1IsoEG.isValid()) {
1069  edm::LogWarning("HLTLevel1GTSeed")
1070  << "\nWarning: L1EmParticleCollection with input tag " << m_l1IsoEGTag
1071  << "\nrequested in configuration, but not found in the event."
1072  << "\nNo IsoEG added to filterproduct." << std::endl;
1073 
1074  } else {
1075  for (std::list<int>::const_iterator itObj = listIsoEG.begin(); itObj != listIsoEG.end(); ++itObj) {
1076 
1077  filterproduct.addObject(trigger::TriggerL1IsoEG, l1extra::L1EmParticleRef(
1078  l1IsoEG, *itObj));
1079 
1080  }
1081  }
1082  }
1083 
1084  // EG (no isolation)
1085  if (!listNoIsoEG.empty()) {
1086  edm::Handle<l1extra::L1EmParticleCollection> l1NoIsoEG;
1087  iEvent.getByToken(m_l1NoIsoEGToken, l1NoIsoEG);
1088 
1089  if (!l1NoIsoEG.isValid()) {
1090  edm::LogWarning("HLTLevel1GTSeed")
1091  << "\nWarning: L1EmParticleCollection with input tag " << m_l1NoIsoEGTag
1092  << "\nrequested in configuration, but not found in the event."
1093  << "\nNo NoIsoEG added to filterproduct." << std::endl;
1094 
1095  } else {
1096  for (std::list<int>::const_iterator itObj = listNoIsoEG.begin(); itObj
1097  != listNoIsoEG.end(); ++itObj) {
1098 
1099  filterproduct.addObject(trigger::TriggerL1NoIsoEG, l1extra::L1EmParticleRef(
1100  l1NoIsoEG, *itObj));
1101 
1102  }
1103  }
1104  }
1105 
1106  // central jets
1107  if (!listCenJet.empty()) {
1108  edm::Handle<l1extra::L1JetParticleCollection> l1CenJet;
1109  iEvent.getByToken(m_l1CenJetToken, l1CenJet);
1110 
1111  if (!l1CenJet.isValid()) {
1112  edm::LogWarning("HLTLevel1GTSeed")
1113  << "\nWarning: L1JetParticleCollection with input tag " << m_l1CenJetTag
1114  << "\nrequested in configuration, but not found in the event."
1115  << "\nNo CenJet added to filterproduct." << std::endl;
1116 
1117  } else {
1118  for (std::list<int>::const_iterator itObj = listCenJet.begin(); itObj
1119  != listCenJet.end(); ++itObj) {
1120 
1121  filterproduct.addObject(trigger::TriggerL1CenJet, l1extra::L1JetParticleRef(
1122  l1CenJet, *itObj));
1123 
1124  }
1125  }
1126  }
1127 
1128  // forward jets
1129  if (!listForJet.empty()) {
1130  edm::Handle<l1extra::L1JetParticleCollection> l1ForJet;
1131  iEvent.getByToken(m_l1ForJetToken, l1ForJet);
1132 
1133  if (!l1ForJet.isValid()) {
1134  edm::LogWarning("HLTLevel1GTSeed")
1135  << "\nWarning: L1JetParticleCollection with input tag " << m_l1ForJetTag
1136  << "\nrequested in configuration, but not found in the event."
1137  << "\nNo ForJet added to filterproduct." << std::endl;
1138 
1139  } else {
1140  for (std::list<int>::const_iterator itObj = listForJet.begin(); itObj
1141  != listForJet.end(); ++itObj) {
1142 
1143  filterproduct.addObject(trigger::TriggerL1ForJet, l1extra::L1JetParticleRef(
1144  l1ForJet, *itObj));
1145 
1146  }
1147  }
1148  }
1149 
1150  // tau jets
1151  if (!listTauJet.empty()) {
1152  edm::Handle<l1extra::L1JetParticleCollection> l1TauJet;
1153  iEvent.getByToken(m_l1TauJetToken, l1TauJet);
1154 
1155  if (!l1TauJet.isValid()) {
1156  edm::LogWarning("HLTLevel1GTSeed")
1157  << "\nWarning: L1JetParticleCollection with input tag " << m_l1TauJetTag
1158  << "\nrequested in configuration, but not found in the event."
1159  << "\nNo TauJet added to filterproduct." << std::endl;
1160 
1161  } else {
1162  for (std::list<int>::const_iterator itObj = listTauJet.begin(); itObj
1163  != listTauJet.end(); ++itObj) {
1164 
1165  filterproduct.addObject(trigger::TriggerL1TauJet, l1extra::L1JetParticleRef(
1166  l1TauJet, *itObj));
1167 
1168  }
1169  }
1170  }
1171 
1172  // isotau jets
1173  if (!listIsoTauJet.empty()) {
1174  edm::Handle<l1extra::L1JetParticleCollection> l1IsoTauJet;
1175  iEvent.getByToken(m_l1IsoTauJetToken, l1IsoTauJet);
1176 
1177  if (!l1IsoTauJet.isValid()) {
1178  edm::LogWarning("HLTLevel1GTSeed")
1179  << "\nWarning: L1JetParticleCollection with input tag " << m_l1IsoTauJetTag
1180  << "\nrequested in configuration, but not found in the event."
1181  << "\nNo IsoTauJet added to filterproduct." << std::endl;
1182 
1183  } else {
1184  for (std::list<int>::const_iterator itObj = listIsoTauJet.begin(); itObj
1185  != listIsoTauJet.end(); ++itObj) {
1186 
1187  filterproduct.addObject(trigger::TriggerL1TauJet, l1extra::L1JetParticleRef(
1188  l1IsoTauJet, *itObj));
1189 
1190  }
1191  }
1192  }
1193 
1194  // energy sums
1195  if (!listETM.empty()) {
1196  edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
1197  iEvent.getByToken(m_l1EtMissMETToken, l1EnergySums);
1198 
1199  if (!l1EnergySums.isValid()) {
1200  edm::LogWarning("HLTLevel1GTSeed")
1201  << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMETTag
1202  << "\nrequested in configuration, but not found in the event."
1203  << "\nNo ETM added to filterproduct." << std::endl;
1204  } else if (l1EnergySums->empty()) {
1205  edm::LogWarning("HLTLevel1GTSeed")
1206  << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMETTag
1207  << "\nfound in the event but with 0 size." << "\nNo ETM added to filterproduct."
1208  << std::endl;
1209 
1210  } else {
1211 
1212  for (std::list<int>::const_iterator itObj = listETM.begin(); itObj != listETM.end(); ++itObj) {
1213 
1214  filterproduct.addObject(trigger::TriggerL1ETM, l1extra::L1EtMissParticleRef(
1215  l1EnergySums, *itObj));
1216 
1217  }
1218 
1219  }
1220 
1221  }
1222 
1223  if (!listETT.empty()) {
1224  edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
1225  iEvent.getByToken(m_l1EtMissMETToken, l1EnergySums);
1226 
1227  if (!l1EnergySums.isValid()) {
1228  edm::LogWarning("HLTLevel1GTSeed")
1229  << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMETTag
1230  << "\nrequested in configuration, but not found in the event."
1231  << "\nNo ETT added to filterproduct." << std::endl;
1232  } else if (l1EnergySums->empty()) {
1233  edm::LogWarning("HLTLevel1GTSeed")
1234  << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMETTag
1235  << "\nfound in the event but with 0 size." << "\nNo ETT added to filterproduct."
1236  << std::endl;
1237 
1238  } else {
1239 
1240  for (std::list<int>::const_iterator itObj = listETT.begin(); itObj != listETT.end(); ++itObj) {
1241 
1242  filterproduct.addObject(trigger::TriggerL1ETT, l1extra::L1EtMissParticleRef(
1243  l1EnergySums, *itObj));
1244 
1245  }
1246 
1247  }
1248 
1249  }
1250 
1251  if (!listHTT.empty()) {
1252  edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
1253  iEvent.getByToken(m_l1EtMissMHTToken, l1EnergySums);
1254 
1255  if (!l1EnergySums.isValid()) {
1256  edm::LogWarning("HLTLevel1GTSeed")
1257  << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMHTTag
1258  << "\nrequested in configuration, but not found in the event."
1259  << "\nNo HTT added to filterproduct." << std::endl;
1260 
1261  } else if (l1EnergySums->empty()) {
1262  edm::LogWarning("HLTLevel1GTSeed")
1263  << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMHTTag
1264  << "\nfound in the event but with 0 size." << "\nNo HTT added to filterproduct."
1265  << std::endl;
1266 
1267  } else {
1268 
1269  for (std::list<int>::const_iterator itObj = listHTT.begin(); itObj != listHTT.end(); ++itObj) {
1270 
1271  filterproduct.addObject(trigger::TriggerL1HTT, l1extra::L1EtMissParticleRef(
1272  l1EnergySums, *itObj));
1273 
1274  }
1275 
1276  }
1277  }
1278 
1279  if (!listHTM.empty()) {
1280  edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
1281  iEvent.getByToken(m_l1EtMissMHTToken, l1EnergySums);
1282 
1283  if (!l1EnergySums.isValid()) {
1284  edm::LogWarning("HLTLevel1GTSeed")
1285  << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMHTTag
1286  << "\nrequested in configuration, but not found in the event."
1287  << "\nNo HTM added to filterproduct." << std::endl;
1288 
1289  } else if (l1EnergySums->empty()) {
1290  edm::LogWarning("HLTLevel1GTSeed")
1291  << "\nWarning: L1EtMissParticleCollection with input tag " << m_l1EtMissMHTTag
1292  << "\nfound in the event but with 0 size." << "\nNo HTM added to filterproduct."
1293  << std::endl;
1294 
1295  } else {
1296 
1297  for (std::list<int>::const_iterator itObj = listHTM.begin(); itObj != listHTM.end(); ++itObj) {
1298 
1299  filterproduct.addObject(trigger::TriggerL1HTM, l1extra::L1EtMissParticleRef(
1300  l1EnergySums, *itObj));
1301 
1302  }
1303  }
1304  }
1305 
1306  // TODO FIXME uncomment if block when JetCounts implemented
1307 
1308  // // jet counts
1309  // if (!listJetCounts.empty()) {
1310  // edm::Handle<l1extra::L1JetCounts> l1JetCounts;
1311  // iEvent.getByToken(m_l1CollectionsToken.label(), l1JetCounts);
1312  //
1313  // for (std::list<int>::const_iterator itObj = listJetCounts.begin();
1314  // itObj != listJetCounts.end(); ++itObj) {
1315  //
1316  // filterproduct.addObject(trigger::TriggerL1JetCounts,l1extra::L1JetCountsRefProd(l1JetCounts));
1317  // // FIXME: RefProd!
1318  //
1319  // }
1320  //
1321  // }
1322 
1323  return seedsResult;
1324 
1325 }
1326 
1327 // seeding is done ignoring if a L1 object fired or not
1328 // if the event is selected at L1, fill all the L1 objects of types corresponding to the
1329 // L1 conditions from the seeding logical expression for bunch crosses F, 0, 1
1330 // directly from L1Extra and use them as seeds at HLT
1331 // method and filter return true if at least an object is filled
1332 bool HLTLevel1GTSeed::seedsL1Extra(edm::Event & iEvent, trigger::TriggerFilterObjectWithRefs & filterproduct) const {
1333 
1334 
1335 
1336  // if (m_isDebugEnabled) {
1337  //
1338  // LogTrace("HLTLevel1GTSeed") << "\n Printing muons from gtDigis\n " << std::endl;
1339  //
1340  // edm::Handle<std::vector<L1MuGMTCand> > muonData;
1341  // iEvent.getByToken("gtDigis", muonData);
1342  //
1343  // if (!muonData.isValid()) {
1344  // edm::LogWarning("HLTLevel1GTSeed")
1345  // << "\nWarning: std::vector<L1MuGMTCand> with input tag "
1346  // << "gtDigis"
1347  // << "\nrequested in configuration, but not found in the event.\n"
1348  // << std::endl;
1349  // } else {
1350  //
1351  // std::vector<L1MuGMTCand>::const_iterator itMuon;
1352  // for (itMuon = muonData->begin(); itMuon != muonData->end(); itMuon++) {
1353  //
1354  // LogTrace("HLTLevel1GTSeed") << (*itMuon) << std::endl;
1355  //
1356  // }
1357  //
1358  // }
1359  // }
1360 
1361  // define bools to prevent entering more copies of the objects
1362  bool includeMuon = true;
1363 
1364  bool includeIsoEG = true;
1365  bool includeNoIsoEG = true;
1366 
1367  bool includeCenJet = true;
1368  bool includeForJet = true;
1369  bool includeTauJet = true;
1370  bool includeIsoTauJet = true;
1371 
1372  bool includeETM = true;
1373  bool includeETT = true;
1374  bool includeHTT = true;
1375  bool includeHTM = true;
1376 
1377  bool includeJetCounts = true;
1378 
1379  //
1380  bool objectsInFilter = false;
1381 
1382  // loop over the list of required algorithms for seeding
1383  int iAlgo = -1;
1384 
1385  for (auto const & m_l1AlgoSeed : m_l1AlgoSeeds) {
1386 
1387  //
1388  iAlgo++;
1389  //
1390  int algBit = m_l1AlgoSeed.tokenNumber;
1391  std::string algName = m_l1AlgoSeed.tokenName;
1392  bool algResult = m_l1AlgoSeed.tokenResult;
1393 
1394  LogTrace("HLTLevel1GTSeed") << "\nHLTLevel1GTSeed::hltFilter "
1395  << "\n Algorithm " << algName << " with bit number " << algBit
1396  << " in the object map seed list" << "\n Algorithm result = "
1397  << algResult << std::endl;
1398 
1399  const std::vector<const std::vector<L1GtObject>*>& algoSeedsObjTypeVec =
1400  m_l1AlgoSeedsObjType[iAlgo];
1401 
1402  int minBxInEvent = (m_l1NrBxInEvent + 1)/2 - m_l1NrBxInEvent;
1403  int maxBxInEvent = (m_l1NrBxInEvent + 1)/2 - 1;
1404 
1405  // loop over all object types found for an algorithm and fill the lists
1406  //
1407  for (auto condObj : algoSeedsObjTypeVec) {
1408 
1409  for (auto itObj : (*condObj)) {
1410 
1411  LogTrace("HLTLevel1GTSeed")
1412  << " Object type in conditions from this algorithm = "
1413  << itObj << std::endl;
1414 
1415  switch (itObj) {
1416  case Mu: {
1417  if (includeMuon) {
1418 
1419  edm::Handle<l1extra::L1MuonParticleCollection> l1Muon;
1420  iEvent.getByToken(m_l1MuonToken, l1Muon);
1421 
1422  if (!l1Muon.isValid()) {
1423  edm::LogWarning("HLTLevel1GTSeed")
1424  << "\nWarning: L1MuonParticleCollection with input tag "
1425  << m_l1MuonTag
1426  << "\nrequested in configuration, but not found in the event."
1427  << "\nNo muon added to filterproduct."
1428  << std::endl;
1429 
1430  } else {
1431  int iObj = -1;
1432  for (auto
1433  objIter = l1Muon->begin(); objIter
1434  != l1Muon->end(); ++objIter) {
1435 
1436  iObj++;
1437 
1438  int bxNr = objIter->bx();
1439  if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
1440 
1441  objectsInFilter = true;
1442  filterproduct.addObject(
1443  trigger::TriggerL1Mu,
1444  l1extra::L1MuonParticleRef(
1445  l1Muon, iObj));
1446  }
1447 
1448  }
1449  }
1450  includeMuon = false;
1451  }
1452  }
1453 
1454  break;
1455  case IsoEG: {
1456  if (includeIsoEG) {
1457  edm::Handle<l1extra::L1EmParticleCollection> l1IsoEG;
1458  iEvent.getByToken(m_l1IsoEGToken, l1IsoEG);
1459 
1460  if (!l1IsoEG.isValid()) {
1461  edm::LogWarning("HLTLevel1GTSeed")
1462  << "\nWarning: L1EmParticleCollection with input tag "
1463  << m_l1IsoEGTag
1464  << "\nrequested in configuration, but not found in the event."
1465  << "\nNo IsoEG added to filterproduct."
1466  << std::endl;
1467 
1468  } else {
1469  int iObj = -1;
1470  for (auto
1471  objIter = l1IsoEG->begin(); objIter
1472  != l1IsoEG->end(); ++objIter) {
1473 
1474  iObj++;
1475 
1476  int bxNr = objIter->bx();
1477  if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
1478 
1479  objectsInFilter = true;
1480  filterproduct.addObject(
1481  trigger::TriggerL1IsoEG,
1482  l1extra::L1EmParticleRef(
1483  l1IsoEG, iObj));
1484 
1485  }
1486  }
1487  }
1488  includeIsoEG = false;
1489  }
1490 
1491  }
1492  break;
1493  case NoIsoEG: {
1494  if (includeNoIsoEG) {
1495  edm::Handle<l1extra::L1EmParticleCollection> l1NoIsoEG;
1496  iEvent.getByToken(m_l1NoIsoEGToken, l1NoIsoEG);
1497 
1498  if (!l1NoIsoEG.isValid()) {
1499  edm::LogWarning("HLTLevel1GTSeed")
1500  << "\nWarning: L1EmParticleCollection with input tag "
1501  << m_l1NoIsoEGTag
1502  << "\nrequested in configuration, but not found in the event."
1503  << "\nNo NoIsoEG added to filterproduct."
1504  << std::endl;
1505 
1506  } else {
1507  int iObj = -1;
1508  for (auto
1509  objIter = l1NoIsoEG->begin(); objIter
1510  != l1NoIsoEG->end(); ++objIter) {
1511 
1512  iObj++;
1513 
1514  int bxNr = objIter->bx();
1515  if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
1516 
1517  objectsInFilter = true;
1518  filterproduct.addObject(
1519  trigger::TriggerL1NoIsoEG,
1520  l1extra::L1EmParticleRef(
1521  l1NoIsoEG, iObj));
1522 
1523  }
1524  }
1525  }
1526  includeNoIsoEG = false;
1527  }
1528 
1529  }
1530  break;
1531  case CenJet: {
1532  if (includeCenJet) {
1533  edm::Handle<l1extra::L1JetParticleCollection> l1CenJet;
1534  iEvent.getByToken(m_l1CenJetToken, l1CenJet);
1535 
1536  if (!l1CenJet.isValid()) {
1537  edm::LogWarning("HLTLevel1GTSeed")
1538  << "\nWarning: L1JetParticleCollection with input tag "
1539  << m_l1CenJetTag
1540  << "\nrequested in configuration, but not found in the event."
1541  << "\nNo CenJet added to filterproduct."
1542  << std::endl;
1543 
1544  } else {
1545  int iObj = -1;
1546  for (auto
1547  objIter = l1CenJet->begin(); objIter
1548  != l1CenJet->end(); ++objIter) {
1549 
1550  iObj++;
1551 
1552  int bxNr = objIter->bx();
1553  if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
1554 
1555  objectsInFilter = true;
1556  filterproduct.addObject(
1557  trigger::TriggerL1CenJet,
1558  l1extra::L1JetParticleRef(
1559  l1CenJet, iObj));
1560 
1561  }
1562  }
1563  }
1564  includeCenJet = false;
1565  }
1566 
1567  }
1568 
1569  break;
1570  case ForJet: {
1571  if (includeForJet) {
1572  edm::Handle<l1extra::L1JetParticleCollection> l1ForJet;
1573  iEvent.getByToken(m_l1ForJetToken, l1ForJet);
1574 
1575  if (!l1ForJet.isValid()) {
1576  edm::LogWarning("HLTLevel1GTSeed")
1577  << "\nWarning: L1JetParticleCollection with input tag "
1578  << m_l1ForJetTag
1579  << "\nrequested in configuration, but not found in the event."
1580  << "\nNo ForJet added to filterproduct."
1581  << std::endl;
1582 
1583  } else {
1584  int iObj = -1;
1585  for (auto
1586  objIter = l1ForJet->begin(); objIter
1587  != l1ForJet->end(); ++objIter) {
1588 
1589  iObj++;
1590 
1591  int bxNr = objIter->bx();
1592  if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
1593 
1594  objectsInFilter = true;
1595  filterproduct.addObject(
1596  trigger::TriggerL1ForJet,
1597  l1extra::L1JetParticleRef(
1598  l1ForJet, iObj));
1599 
1600  }
1601  }
1602  }
1603  includeForJet = false;
1604  }
1605 
1606  }
1607 
1608  break;
1609  case TauJet: {
1610  if (includeTauJet) {
1611  edm::Handle<l1extra::L1JetParticleCollection> l1TauJet;
1612  iEvent.getByToken(m_l1TauJetToken, l1TauJet);
1613 
1614  if (!l1TauJet.isValid()) {
1615  edm::LogWarning("HLTLevel1GTSeed")
1616  << "\nWarning: L1JetParticleCollection with input tag "
1617  << m_l1TauJetTag
1618  << "\nrequested in configuration, but not found in the event."
1619  << "\nNo TauJet added to filterproduct."
1620  << std::endl;
1621 
1622  } else {
1623  int iObj = -1;
1624  for (auto
1625  objIter = l1TauJet->begin(); objIter
1626  != l1TauJet->end(); ++objIter) {
1627 
1628  iObj++;
1629 
1630  int bxNr = objIter->bx();
1631  if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
1632 
1633  objectsInFilter = true;
1634  filterproduct.addObject(
1635  trigger::TriggerL1TauJet,
1636  l1extra::L1JetParticleRef(
1637  l1TauJet, iObj));
1638 
1639  }
1640  }
1641  }
1642  includeTauJet = false;
1643  }
1644 
1645  }
1646 
1647  case HfRingEtSums: {
1648  if (includeIsoTauJet) {
1649  edm::Handle<l1extra::L1JetParticleCollection> l1IsoTauJet;
1650  iEvent.getByToken(m_l1IsoTauJetToken, l1IsoTauJet);
1651 
1652  if (!l1IsoTauJet.isValid()) {
1653  edm::LogWarning("HLTLevel1GTSeed")
1654  << "\nWarning: L1JetParticleCollection with input tag "
1655  << m_l1IsoTauJetTag
1656  << "\nrequested in configuration, but not found in the event."
1657  << "\nNo IsoTauJet added to filterproduct."
1658  << std::endl;
1659 
1660  } else {
1661  int iObj = -1;
1662  for (auto
1663  objIter = l1IsoTauJet->begin(); objIter
1664  != l1IsoTauJet->end(); ++objIter) {
1665 
1666  iObj++;
1667 
1668  int bxNr = objIter->bx();
1669  if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
1670 
1671  objectsInFilter = true;
1672  filterproduct.addObject(
1673  trigger::TriggerL1TauJet,
1674  l1extra::L1JetParticleRef(
1675  l1IsoTauJet, iObj));
1676 
1677  }
1678  }
1679  }
1680  includeIsoTauJet = false;
1681  }
1682 
1683  }
1684 
1685  break;
1686  case ETM: {
1687  if (includeETM) {
1688  edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
1689  iEvent.getByToken(m_l1EtMissMETToken, l1EnergySums);
1690 
1691  if (!l1EnergySums.isValid()) {
1692  edm::LogWarning("HLTLevel1GTSeed")
1693  << "\nWarning: L1EtMissParticleCollection with input tag "
1694  << m_l1EtMissMETTag
1695  << "\nrequested in configuration, but not found in the event."
1696  << "\nNo ETM added to filterproduct."
1697  << std::endl;
1698 
1699  } else if (l1EnergySums->empty()) {
1700  edm::LogWarning("HLTLevel1GTSeed")
1701  << "\nWarning: L1EtMissParticleCollection with input tag "
1702  << m_l1EtMissMETTag
1703  << "\nfound in the event but with 0 size."
1704  << "\nNo ETM added to filterproduct."
1705  << std::endl;
1706 
1707  } else {
1708  int iObj = -1;
1709  for (auto
1710  objIter = l1EnergySums->begin(); objIter
1711  != l1EnergySums->end(); ++objIter) {
1712 
1713  iObj++;
1714 
1715  int bxNr = objIter->bx();
1716  if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
1717 
1718  objectsInFilter = true;
1719  filterproduct.addObject(
1720  trigger::TriggerL1ETM,
1721  l1extra::L1EtMissParticleRef(
1722  l1EnergySums, iObj));
1723 
1724  }
1725  }
1726  }
1727  includeETM = false;
1728  }
1729 
1730  }
1731 
1732  break;
1733  case ETT: {
1734  if (includeETT) {
1735  edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
1736  iEvent.getByToken(m_l1EtMissMETToken, l1EnergySums);
1737 
1738  if (!l1EnergySums.isValid()) {
1739  edm::LogWarning("HLTLevel1GTSeed")
1740  << "\nWarning: L1EtMissParticleCollection with input tag "
1741  << m_l1EtMissMETTag
1742  << "\nrequested in configuration, but not found in the event."
1743  << "\nNo ETT added to filterproduct."
1744  << std::endl;
1745 
1746  } else if (l1EnergySums->empty()) {
1747  edm::LogWarning("HLTLevel1GTSeed")
1748  << "\nWarning: L1EtMissParticleCollection with input tag "
1749  << m_l1EtMissMETTag
1750  << "\nfound in the event but with 0 size."
1751  << "\nNo ETT added to filterproduct."
1752  << std::endl;
1753 
1754  } else {
1755  int iObj = -1;
1756  for (auto
1757  objIter = l1EnergySums->begin(); objIter
1758  != l1EnergySums->end(); ++objIter) {
1759 
1760  iObj++;
1761 
1762  int bxNr = objIter->bx();
1763  if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
1764 
1765  objectsInFilter = true;
1766  filterproduct.addObject(
1767  trigger::TriggerL1ETT,
1768  l1extra::L1EtMissParticleRef(
1769  l1EnergySums, iObj));
1770 
1771  }
1772  }
1773  }
1774  includeETT = false;
1775  }
1776 
1777  }
1778 
1779  break;
1780  case HTT: {
1781  if (includeHTT) {
1782  edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
1783  iEvent.getByToken(m_l1EtMissMHTToken, l1EnergySums);
1784 
1785  if (!l1EnergySums.isValid()) {
1786  edm::LogWarning("HLTLevel1GTSeed")
1787  << "\nWarning: L1EtMissParticleCollection with input tag "
1788  << m_l1EtMissMHTTag
1789  << "\nrequested in configuration, but not found in the event."
1790  << "\nNo HTT added to filterproduct."
1791  << std::endl;
1792 
1793  } else if (l1EnergySums->empty()) {
1794  edm::LogWarning("HLTLevel1GTSeed")
1795  << "\nWarning: L1EtMissParticleCollection with input tag "
1796  << m_l1EtMissMHTTag
1797  << "\nfound in the event but with 0 size."
1798  << "\nNo HTT added to filterproduct."
1799  << std::endl;
1800 
1801  } else {
1802  int iObj = -1;
1803  for (auto
1804  objIter = l1EnergySums->begin(); objIter
1805  != l1EnergySums->end(); ++objIter) {
1806 
1807  iObj++;
1808 
1809  int bxNr = objIter->bx();
1810  if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
1811 
1812  objectsInFilter = true;
1813  filterproduct.addObject(
1814  trigger::TriggerL1HTT,
1815  l1extra::L1EtMissParticleRef(
1816  l1EnergySums, iObj));
1817 
1818  }
1819  }
1820  }
1821  includeHTT = false;
1822  }
1823  }
1824 
1825  break;
1826  case HTM: {
1827  if (includeHTM) {
1828  edm::Handle<l1extra::L1EtMissParticleCollection> l1EnergySums;
1829  iEvent.getByToken(m_l1EtMissMHTToken, l1EnergySums);
1830 
1831  if (!l1EnergySums.isValid()) {
1832  edm::LogWarning("HLTLevel1GTSeed")
1833  << "\nWarning: L1EtMissParticleCollection with input tag "
1834  << m_l1EtMissMHTTag
1835  << "\nrequested in configuration, but not found in the event."
1836  << "\nNo HTM added to filterproduct."
1837  << std::endl;
1838 
1839  } else if (l1EnergySums->empty()) {
1840  edm::LogWarning("HLTLevel1GTSeed")
1841  << "\nWarning: L1EtMissParticleCollection with input tag "
1842  << m_l1EtMissMHTTag
1843  << "\nfound in the event but with 0 size."
1844  << "\nNo HTM added to filterproduct."
1845  << std::endl;
1846 
1847  } else {
1848  int iObj = -1;
1849  for (auto
1850  objIter = l1EnergySums->begin(); objIter
1851  != l1EnergySums->end(); ++objIter) {
1852 
1853  iObj++;
1854 
1855  int bxNr = objIter->bx();
1856  if ((bxNr >= minBxInEvent) && (bxNr <= maxBxInEvent)) {
1857 
1858  objectsInFilter = true;
1859  filterproduct.addObject(
1860  trigger::TriggerL1HTM,
1861  l1extra::L1EtMissParticleRef(
1862  l1EnergySums, iObj));
1863 
1864  }
1865  }
1866  }
1867  includeHTM = false;
1868  }
1869  }
1870 
1871  break;
1872  case JetCounts: {
1873  if (includeJetCounts) {
1874  // do nothing, JetCounts do not exist now
1875  }
1876  }
1877 
1878  break;
1879  default: {
1880  // should not arrive here
1881 
1882  LogDebug("HLTLevel1GTSeed")
1883  << "\n HLTLevel1GTSeed::hltFilter "
1884  << "\n Unknown object of type " << itObj
1885  << " in the seed list." << std::endl;
1886  }
1887  break;
1888  }
1889 
1890  }
1891 
1892  }
1893 
1894  LogTrace("HLTLevel1GTSeed") << std::endl;
1895  }
1896 
1897  return objectsInFilter;
1898 
1899 }
1900 
1901 // detailed print of filter content
1902 void HLTLevel1GTSeed::dumpTriggerFilterObjectWithRefs(trigger::TriggerFilterObjectWithRefs & filterproduct) const
1903 {
1904  LogDebug("HLTLevel1GTSeed") << "\nHLTLevel1GTSeed::hltFilter "
1905  << "\n Dump TriggerFilterObjectWithRefs\n" << std::endl;
1906 
1907  std::vector<l1extra::L1MuonParticleRef> seedsL1Mu;
1908 
1909  std::vector<l1extra::L1EmParticleRef> seedsL1IsoEG;
1910  std::vector<l1extra::L1EmParticleRef> seedsL1NoIsoEG;
1911 
1912  std::vector<l1extra::L1JetParticleRef> seedsL1CenJet;
1913  std::vector<l1extra::L1JetParticleRef> seedsL1ForJet;
1914  std::vector<l1extra::L1JetParticleRef> seedsL1TauJet;
1915  std::vector<l1extra::L1JetParticleRef> seedsL1IsoTauJet;
1916 
1917  std::vector<l1extra::L1EtMissParticleRef> seedsL1ETM;
1918  std::vector<l1extra::L1EtMissParticleRef> seedsL1ETT;
1919  std::vector<l1extra::L1EtMissParticleRef> seedsL1HTT;
1920  std::vector<l1extra::L1EtMissParticleRef> seedsL1HTM;
1921 
1922  filterproduct.getObjects(trigger::TriggerL1Mu, seedsL1Mu);
1923  const size_t sizeSeedsL1Mu = seedsL1Mu.size();
1924 
1925  filterproduct.getObjects(trigger::TriggerL1IsoEG, seedsL1IsoEG);
1926  const size_t sizeSeedsL1IsoEG = seedsL1IsoEG.size();
1927 
1928  filterproduct.getObjects(trigger::TriggerL1NoIsoEG, seedsL1NoIsoEG);
1929  const size_t sizeSeedsL1NoIsoEG = seedsL1NoIsoEG.size();
1930 
1931  filterproduct.getObjects(trigger::TriggerL1CenJet, seedsL1CenJet);
1932  const size_t sizeSeedsL1CenJet = seedsL1CenJet.size();
1933 
1934  filterproduct.getObjects(trigger::TriggerL1ForJet, seedsL1ForJet);
1935  const size_t sizeSeedsL1ForJet = seedsL1ForJet.size();
1936 
1937  filterproduct.getObjects(trigger::TriggerL1TauJet, seedsL1TauJet);
1938  const size_t sizeSeedsL1TauJet = seedsL1TauJet.size();
1939 
1940  filterproduct.getObjects(trigger::TriggerL1TauJet, seedsL1IsoTauJet);
1941  const size_t sizeSeedsL1IsoTauJet = seedsL1IsoTauJet.size();
1942 
1943  filterproduct.getObjects(trigger::TriggerL1ETM, seedsL1ETM);
1944  const size_t sizeSeedsL1ETM = seedsL1ETM.size();
1945 
1946  filterproduct.getObjects(trigger::TriggerL1ETT, seedsL1ETT);
1947  const size_t sizeSeedsL1ETT = seedsL1ETT.size();
1948 
1949  filterproduct.getObjects(trigger::TriggerL1HTT, seedsL1HTT);
1950  const size_t sizeSeedsL1HTT = seedsL1HTT.size();
1951 
1952  filterproduct.getObjects(trigger::TriggerL1HTM, seedsL1HTM);
1953  const size_t sizeSeedsL1HTM = seedsL1HTM.size();
1954 
1955  LogTrace("HLTLevel1GTSeed") << " L1Mu seeds: " << sizeSeedsL1Mu << "\n"
1956  << " L1IsoEG seeds: " << sizeSeedsL1IsoEG << "\n"
1957  << " L1NoIsoEG seeds: " << sizeSeedsL1NoIsoEG << "\n"
1958  << " L1CenJet seeds: " << sizeSeedsL1CenJet << "\n"
1959  << " L1ForJet seeds: " << sizeSeedsL1ForJet << "\n"
1960  << " L1TauJet seeds: " << sizeSeedsL1TauJet << "\n"
1961  << " L1IsoTauJet seeds: " << sizeSeedsL1IsoTauJet << "\n"
1962  << " L1ETM seeds: " << sizeSeedsL1ETM << "\n"
1963  << " L1ETT seeds: " << sizeSeedsL1ETT << "\n"
1964  << " L1HTT seeds: " << sizeSeedsL1HTT << "\n"
1965  << " L1HTM seeds: " << sizeSeedsL1HTM << "\n" << std::endl;
1966 
1967  for (size_t i = 0; i != sizeSeedsL1Mu; i++) {
1968 
1969  l1extra::L1MuonParticleRef obj = l1extra::L1MuonParticleRef(
1970  seedsL1Mu[i]);
1971 
1972  LogTrace("HLTLevel1GTSeed") << "L1Mu " << "\t" << "q*PT = "
1973  << obj->charge() * obj->pt() << "\t" << "eta = " << obj->eta()
1974  << "\t" << "phi = " << obj->phi() << "\t" << "BX = "
1975  << obj->bx();
1976  }
1977 
1978  for (size_t i = 0; i != sizeSeedsL1IsoEG; i++) {
1979 
1980  l1extra::L1EmParticleRef obj =
1981  l1extra::L1EmParticleRef(seedsL1IsoEG[i]);
1982 
1983  LogTrace("HLTLevel1GTSeed") << "L1IsoEG " << "\t" << "ET = "
1984  << obj->et() << "\t" << "eta = " << obj->eta() << "\t"
1985  << "phi = " << obj->phi() << "\t" << "BX = " << obj->bx();
1986  ;
1987  }
1988 
1989  for (size_t i = 0; i != sizeSeedsL1NoIsoEG; i++) {
1990 
1991  l1extra::L1EmParticleRef obj = l1extra::L1EmParticleRef(
1992  seedsL1NoIsoEG[i]);
1993 
1994  LogTrace("HLTLevel1GTSeed") << "L1NoIsoEG" << "\t" << "ET = "
1995  << obj->et() << "\t" << "eta = " << obj->eta() << "\t"
1996  << "phi = " << obj->phi() << "\t" << "BX = " << obj->bx();
1997  }
1998 
1999  for (size_t i = 0; i != sizeSeedsL1CenJet; i++) {
2000 
2001  l1extra::L1JetParticleRef obj = l1extra::L1JetParticleRef(
2002  seedsL1CenJet[i]);
2003 
2004  LogTrace("HLTLevel1GTSeed") << "L1CenJet " << "\t" << "ET = "
2005  << obj->et() << "\t" << "eta = " << obj->eta() << "\t"
2006  << "phi = " << obj->phi() << "\t" << "BX = " << obj->bx();
2007  }
2008 
2009  for (size_t i = 0; i != sizeSeedsL1ForJet; i++) {
2010 
2011  l1extra::L1JetParticleRef obj = l1extra::L1JetParticleRef(
2012  seedsL1ForJet[i]);
2013 
2014  LogTrace("HLTLevel1GTSeed") << "L1ForJet " << "\t" << "ET = "
2015  << obj->et() << "\t" << "eta = " << obj->eta() << "\t"
2016  << "phi = " << obj->phi() << "\t" << "BX = " << obj->bx();
2017  }
2018 
2019  for (size_t i = 0; i != sizeSeedsL1TauJet; i++) {
2020 
2021  l1extra::L1JetParticleRef obj = l1extra::L1JetParticleRef(
2022  seedsL1TauJet[i]);
2023 
2024  LogTrace("HLTLevel1GTSeed") << "L1TauJet " << "\t" << "ET = "
2025  << obj->et() << "\t" << "eta = " << obj->eta() << "\t"
2026  << "phi = " << obj->phi() << "\t" << "BX = " << obj->bx();
2027  }
2028 
2029  for (size_t i = 0; i != sizeSeedsL1IsoTauJet; i++) {
2030 
2031  l1extra::L1JetParticleRef obj = l1extra::L1JetParticleRef(
2032  seedsL1IsoTauJet[i]);
2033 
2034  LogTrace("HLTLevel1GTSeed") << "L1IsoTauJet " << "\t" << "ET = "
2035  << obj->et() << "\t" << "eta = " << obj->eta() << "\t"
2036  << "phi = " << obj->phi() << "\t" << "BX = " << obj->bx();
2037  }
2038 
2039  for (size_t i = 0; i != sizeSeedsL1ETM; i++) {
2040 
2041  l1extra::L1EtMissParticleRef obj = l1extra::L1EtMissParticleRef(
2042  seedsL1ETM[i]);
2043 
2044  LogTrace("HLTLevel1GTSeed") << "L1ETM " << "\t" << "ET = "
2045  << obj->etMiss() << "\t" << "phi = " << obj->phi() << "BX = "
2046  << obj->bx();
2047  }
2048 
2049  for (size_t i = 0; i != sizeSeedsL1ETT; i++) {
2050 
2051  l1extra::L1EtMissParticleRef obj = l1extra::L1EtMissParticleRef(
2052  seedsL1ETT[i]);
2053 
2054  LogTrace("HLTLevel1GTSeed") << "L1ETT " << "\t" << "ET = "
2055  << obj->etTotal() << "\t" << "BX = " << obj->bx();
2056  }
2057 
2058  for (size_t i = 0; i != sizeSeedsL1HTT; i++) {
2059 
2060  l1extra::L1EtMissParticleRef obj = l1extra::L1EtMissParticleRef(
2061  seedsL1HTT[i]);
2062 
2063  LogTrace("HLTLevel1GTSeed") << "L1HTT " << "\t" << "ET = "
2064  << obj->etTotal() << "\t" << "BX = " << obj->bx();
2065  }
2066 
2067  for (size_t i = 0; i != sizeSeedsL1HTM; i++) {
2068 
2069  l1extra::L1EtMissParticleRef obj = l1extra::L1EtMissParticleRef(
2070  seedsL1HTM[i]);
2071 
2072  LogTrace("HLTLevel1GTSeed") << "L1HTM " << "\t" << "ET = "
2073  << obj->etMiss() << "\t" << "phi = " << obj->phi() << "BX = "
2074  << obj->bx();
2075  }
2076 
2077  LogTrace("HLTLevel1GTSeed") << " \n\n" << std::endl;
2078 
2079 }
2080 
2081 // register as framework plugin
2082 #include "FWCore/Framework/interface/MakerMacros.h"
2083 DEFINE_FWK_MODULE(HLTLevel1GTSeed);
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:670
findQualityFiles.size
size
Write out results.
Definition: findQualityFiles.py:443
L1GtLogicParser::expressionSeedsOperandList
std::vector< L1GtLogicParser::OperandToken > expressionSeedsOperandList()
Definition: L1GtLogicParser.cc:1228
L1GtTriggerMenu::gtTriggerMenuName
const std::string & gtTriggerMenuName() const
Definition: L1GtTriggerMenu.h:99
edm::isDebugEnabled
bool isDebugEnabled()
Definition: MessageLogger.cc:71
HLTLevel1GTSeed::m_l1UseL1TriggerObjectMaps
bool m_l1UseL1TriggerObjectMaps
Definition: HLTLevel1GTSeed.h:141
trigger::TriggerRefsCollections::getObjects
void getObjects(Vids &ids, VRphoton &refs) const
various physics-level getters:
Definition: TriggerRefsCollections.h:434
mps_fire.i
i
Definition: mps_fire.py:338
HLTLevel1GTSeed::dumpTriggerFilterObjectWithRefs
void dumpTriggerFilterObjectWithRefs(trigger::TriggerFilterObjectWithRefs &) const
detailed print of filter content
Definition: HLTLevel1GTSeed.cc:1902
L1GlobalTriggerReadoutRecord::technicalTriggerWord
const TechnicalTriggerWord & technicalTriggerWord(int bxInEventValue) const
Definition: L1GlobalTriggerReadoutRecord.cc:275
HTM
Definition: L1GtObject.h:39
HLTLevel1GTSeed::m_l1GtMenu
const L1GtTriggerMenu * m_l1GtMenu
trigger menu
Definition: HLTLevel1GTSeed.h:115
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:517
trigger::TriggerL1Mu
enum start value shifted to 81 so as to avoid clashes with PDG codes
Definition: TriggerTypeDefs.h:31
ConditionMap
std::map< std::string, L1GtCondition * > ConditionMap
map containing the conditions
Definition: L1GtTriggerMenuFwd.h:28
HLTLevel1GTSeed::seedsL1Extra
bool seedsL1Extra(edm::Event &, trigger::TriggerFilterObjectWithRefs &) const
Definition: HLTLevel1GTSeed.cc:1332
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
ETM
Definition: L1GtObject.h:36
AlgorithmMap
std::map< std::string, L1GtAlgorithm > AlgorithmMap
map containing the algorithms
Definition: L1GtTriggerMenuFwd.h:31
L1GlobalTriggerObjectMap::operandTokenVector
const std::vector< L1GtLogicParser::OperandToken > & operandTokenVector() const
Definition: L1GlobalTriggerObjectMap.h:93
HLTLevel1GTSeed::m_l1EtMissMETTag
edm::InputTag m_l1EtMissMETTag
Definition: HLTLevel1GTSeed.h:187
HLTLevel1GTSeed::m_l1EtMissMHTToken
edm::EDGetTokenT< l1extra::L1EtMissParticleCollection > m_l1EtMissMHTToken
Definition: HLTLevel1GTSeed.h:190
nullptr
#define nullptr
Definition: GCC11Compatibility.h:37
triggerObjects_cff.l1Muon
l1Muon
Definition: triggerObjects_cff.py:24
HLTLevel1GTSeed::debugPrint
void debugPrint(bool) const
Definition: HLTLevel1GTSeed.cc:602
L1GlobalTriggerReadoutRecord::finalOR
const cms_uint16_t finalOR(int bxInEventValue) const
Definition: L1GlobalTriggerReadoutRecord.cc:203
HLTLevel1GTSeed::m_l1AlgoSeeds
std::vector< L1GtLogicParser::OperandToken > m_l1AlgoSeeds
list of required algorithms for seeding
Definition: HLTLevel1GTSeed.h:122
HLTLevel1GTSeed::m_l1UseAliasesForSeeding
bool m_l1UseAliasesForSeeding
seeding uses algorithm aliases instead of algorithm names, if value is "true"
Definition: HLTLevel1GTSeed.h:151
HLTLevel1GTSeed::m_l1IsoTauJetTag
edm::InputTag m_l1IsoTauJetTag
Definition: HLTLevel1GTSeed.h:185
L1GtTriggerMenu::gtConditionMap
const std::vector< ConditionMap > & gtConditionMap() const
get / set / build the condition maps
Definition: L1GtTriggerMenu.h:84
L1GlobalTriggerReadoutRecord::printGtDecision
void printGtDecision(std::ostream &myCout, int bxInEventValue) const
print global decision and algorithm decision word
Definition: L1GlobalTriggerReadoutRecord.cc:415
HLTLevel1GTSeed::m_l1ForJetToken
edm::EDGetTokenT< l1extra::L1JetParticleCollection > m_l1ForJetToken
Definition: HLTLevel1GTSeed.h:182
HLTLevel1GTSeed::m_l1ExtraTag
edm::InputTag m_l1ExtraTag
cached InputTags
Definition: HLTLevel1GTSeed.h:172
HLTLevel1GTSeed::m_l1TechTriggerSeeding
bool m_l1TechTriggerSeeding
seeding done via technical trigger bits, if value is "true"
Definition: HLTLevel1GTSeed.h:148
HTT
Definition: L1GtObject.h:38
trigger::TriggerRefsCollections::addObject
void addObject(int id, const reco::RecoEcalCandidateRef &ref)
setters for L3 collections: (id=physics type, and Ref<C>)
Definition: TriggerRefsCollections.h:217
HLTLevel1GTSeed::m_l1EtMissMHTTag
edm::InputTag m_l1EtMissMHTTag
Definition: HLTLevel1GTSeed.h:189
label
char const * label
Definition: PFTauDecayModeTools.cc:11
HLTLevel1GTSeed::m_l1GtObjectMapTag
edm::InputTag m_l1GtObjectMapTag
InputTag for L1 Global Trigger object maps.
Definition: HLTLevel1GTSeed.h:162
HLTLevel1GTSeed::hltFilter
bool hltFilter(edm::Event &, const edm::EventSetup &, trigger::TriggerFilterObjectWithRefs &filterproduct) override
filter the event
Definition: HLTLevel1GTSeed.cc:254
iEvent
int iEvent
Definition: GenABIO.cc:224
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
L1GtLogicParser::operandTokenVector
std::vector< OperandToken > & operandTokenVector()
return the vector of operand tokens
Definition: L1GtLogicParser.h:122
L1GtTriggerMask::gtTriggerMask
const std::vector< unsigned int > & gtTriggerMask() const
get the trigger mask
Definition: L1GtTriggerMask.h:51
HLTLevel1GTSeed::m_l1EtMissMETToken
edm::EDGetTokenT< l1extra::L1EtMissParticleCollection > m_l1EtMissMETToken
Definition: HLTLevel1GTSeed.h:188
L1GlobalTriggerObjectMap::getCombinationsInCond
const CombinationsInCond * getCombinationsInCond(const std::string &condNameVal) const
return all the combinations passing the requirements imposed in condition condNameVal ...
Definition: L1GlobalTriggerObjectMap.cc:38
HLTLevel1GTSeed::m_l1GtReadoutRecordToken
edm::EDGetTokenT< L1GlobalTriggerReadoutRecord > m_l1GtReadoutRecordToken
Definition: HLTLevel1GTSeed.h:159
HLTLevel1GTSeed::m_l1AlgoSeedsObjType
std::vector< std::vector< const std::vector< L1GtObject > * > > m_l1AlgoSeedsObjType
vector of object-type vectors for each condition in the required algorithms for seeding ...
Definition: HLTLevel1GTSeed.h:128
HLTLevel1GTSeed::m_l1IsoTauJetToken
edm::EDGetTokenT< l1extra::L1JetParticleCollection > m_l1IsoTauJetToken
Definition: HLTLevel1GTSeed.h:186
HLTLevel1GTSeed::m_l1CollectionsTag
edm::InputTag m_l1CollectionsTag
Meta InputTag for L1 particle collections (except muon)
Definition: HLTLevel1GTSeed.h:166
HLTLevel1GTSeed::m_l1MuonCollectionTag
edm::InputTag m_l1MuonCollectionTag
Meta InputTag for L1 muon collection.
Definition: HLTLevel1GTSeed.h:169
HLTLevel1GTSeed::m_l1CenJetToken
edm::EDGetTokenT< l1extra::L1JetParticleCollection > m_l1CenJetToken
Definition: HLTLevel1GTSeed.h:180
HLTLevel1GTSeed::updateAlgoLogicParser
void updateAlgoLogicParser(const L1GtTriggerMenu *, const AlgorithmMap &)
Definition: HLTLevel1GTSeed.cc:405
HLTLevel1GTSeed::m_l1IsoEGToken
edm::EDGetTokenT< l1extra::L1EmParticleCollection > m_l1IsoEGToken
Definition: HLTLevel1GTSeed.h:176
HLTLevel1GTSeed::m_l1SeedsLogicalExpression
std::string m_l1SeedsLogicalExpression
Definition: HLTLevel1GTSeed.h:155
HLTLevel1GTSeed::m_l1IsoEGTag
edm::InputTag m_l1IsoEGTag
Definition: HLTLevel1GTSeed.h:175
HLTLevel1GTSeed::m_l1GtMenuCacheID
unsigned long long m_l1GtMenuCacheID
Definition: HLTLevel1GTSeed.h:116
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:74
l1extra::L1JetParticleRef
edm::Ref< L1JetParticleCollection > L1JetParticleRef
Definition: L1JetParticleFwd.h:33
HLTLevel1GTSeed::m_l1ForJetTag
edm::InputTag m_l1ForJetTag
Definition: HLTLevel1GTSeed.h:181
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
L1GlobalTriggerReadoutRecord::decisionWord
const DecisionWord & decisionWord(int bxInEventValue) const
Definition: L1GlobalTriggerReadoutRecord.cc:239
HLTLevel1GTSeed::m_isDebugEnabled
bool m_isDebugEnabled
cache edm::isDebugEnabled()
Definition: HLTLevel1GTSeed.h:196
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:79
HLTLevel1GTSeed::m_l1CenJetTag
edm::InputTag m_l1CenJetTag
Definition: HLTLevel1GTSeed.h:179
HLTLevel1GTSeed::m_l1AlgoSeedsRpn
std::vector< const std::vector< L1GtLogicParser::TokenRPN > * > m_l1AlgoSeedsRpn
vector of Rpn vectors for the required algorithms for seeding
Definition: HLTLevel1GTSeed.h:125
HLTLevel1GTSeed::m_l1NoIsoEGTag
edm::InputTag m_l1NoIsoEGTag
Definition: HLTLevel1GTSeed.h:177
electrons_cff.bool
bool
Definition: electrons_cff.py:359
L1GtTriggerMenu::gtTriggerMenuInterface
const std::string & gtTriggerMenuInterface() const
get / set the trigger menu names
Definition: L1GtTriggerMenu.h:92
HLTLevel1GTSeed::convertStringToBitNumber
void convertStringToBitNumber()
Definition: HLTLevel1GTSeed.cc:556
HLTLevel1GTSeed::m_l1TauJetToken
edm::EDGetTokenT< l1extra::L1JetParticleCollection > m_l1TauJetToken
Definition: HLTLevel1GTSeed.h:184
HLTLevel1GTSeed::m_l1GtObjectMapToken
edm::EDGetTokenT< L1GlobalTriggerObjectMapRecord > m_l1GtObjectMapToken
Definition: HLTLevel1GTSeed.h:163
Mu
Definition: L1GtObject.h:30
edm::Handle::product
T const * product() const
Definition: Handle.h:74
HLTLevel1GTSeed::objectTypeVec
const std::vector< L1GtObject > * objectTypeVec(const int chipNumber, const std::string &cndName) const
get the vector of object types for a condition cndName on the GTL chip chipNumber ...
Definition: HLTLevel1GTSeed.cc:389
trigger::TriggerFilterObjectWithRefs::addCollectionTag
void addCollectionTag(const edm::InputTag &collectionTag)
collectionTags
Definition: TriggerFilterObjectWithRefs.h:64
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
l1extra::L1MuonParticleRef
edm::Ref< L1MuonParticleCollection > L1MuonParticleRef
Definition: L1MuonParticleFwd.h:33
HLTLevel1GTSeed::m_l1GtReadoutRecordTag
edm::InputTag m_l1GtReadoutRecordTag
InputTag for the L1 Global Trigger DAQ readout record.
Definition: HLTLevel1GTSeed.h:158
HLTLevel1GTSeed::m_l1GlobalDecision
bool m_l1GlobalDecision
replace string "L1GlobalDecision" with bool to speed up the "if"
Definition: HLTLevel1GTSeed.h:193
ETT
Definition: L1GtObject.h:37
edm
HLT enums.
Definition: AlignableModifier.h:17
l1extra::L1EtMissParticleRef
edm::Ref< L1EtMissParticleCollection > L1EtMissParticleRef
Definition: L1EtMissParticleFwd.h:35
edm::EventSetup::get
T get() const
Definition: EventSetup.h:71
HLTLevel1GTSeed::m_l1MuonToken
edm::EDGetTokenT< l1extra::L1MuonParticleCollection > m_l1MuonToken
Definition: HLTLevel1GTSeed.h:174
l1extra::L1EmParticleRef
edm::Ref< L1EmParticleCollection > L1EmParticleRef
Definition: L1EmParticleFwd.h:33
L1GtTriggerMenu::gtAlgorithmMap
const AlgorithmMap & gtAlgorithmMap() const
get / set the algorithm map (by name)
Definition: L1GtTriggerMenu.h:241
HLTLevel1GTSeed::HLTLevel1GTSeed
HLTLevel1GTSeed(const edm::ParameterSet &)
constructor
Definition: HLTLevel1GTSeed.cc:76
HLTLevel1GTSeed::m_l1NoIsoEGToken
edm::EDGetTokenT< l1extra::L1EmParticleCollection > m_l1NoIsoEGToken
Definition: HLTLevel1GTSeed.h:178
HLTLevel1GTSeed::seedsL1TriggerObjectMaps
bool seedsL1TriggerObjectMaps(edm::Event &, trigger::TriggerFilterObjectWithRefs &, const L1GtTriggerMask *, const L1GlobalTriggerReadoutRecord *, const int physicsDaqPartition)
seeding is done via L1 trigger object maps, considering the objects which fired in L1 ...
Definition: HLTLevel1GTSeed.cc:713
HLTLevel1GTSeed::m_l1MuonTag
edm::InputTag m_l1MuonTag
Definition: HLTLevel1GTSeed.h:173
HLTLevel1GTSeed::m_l1AlgoLogicParser
L1GtLogicParser m_l1AlgoLogicParser
logic parser for m_l1SeedsLogicalExpression
Definition: HLTLevel1GTSeed.h:119
l1extra::L1EtMissParticleCollection
std::vector< L1EtMissParticle > L1EtMissParticleCollection
Definition: L1EtMissParticleFwd.h:33
L1GtTriggerMenu::gtAlgorithmAliasMap
const AlgorithmMap & gtAlgorithmAliasMap() const
get / set the algorithm map (by alias)
Definition: L1GtTriggerMenu.h:248
HLTLevel1GTSeed::m_l1TauJetTag
edm::InputTag m_l1TauJetTag
Definition: HLTLevel1GTSeed.h:183
cmsPerfPublish.fail
def fail(errstr="")
Definition: cmsPerfPublish.py:67
CombinationsInCond
std::vector< SingleCombInCond > CombinationsInCond
all the object combinations evaluated to true in the condition
Definition: L1GlobalTriggerObjectMapFwd.h:32
HLTStreamFilter::makeHLTFilterDescription
static void makeHLTFilterDescription(edm::ParameterSetDescription &desc)
Definition: HLTStreamFilter.cc:29
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
HLTLevel1GTSeed::~HLTLevel1GTSeed
~HLTLevel1GTSeed() override
destructor
Definition: HLTLevel1GTSeed.cc:190
L1GlobalTriggerObjectMapRecord::getObjectMap
const L1GlobalTriggerObjectMap * getObjectMap(const std::string &algoNameVal) const
return the object map for the algorithm algoNameVal
Definition: L1GlobalTriggerObjectMapRecord.cc:35
HLTLevel1GTSeed::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
parameter description
Definition: HLTLevel1GTSeed.cc:197
HLTStreamFilter::saveTags
bool saveTags() const
Definition: HLTStreamFilter.h:46
L1GtLogicParser::expressionResult
virtual const bool expressionResult() const
Definition: L1GtLogicParser.cc:685
Generated for CMSSW Reference Manual by doxygen 1.8.11