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