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