HLTcore/plugins/HLTEventAnalyzerAOD.cc

0001 /** \class HLTEventAnalyzerAOD
0002  *
0003  * See header file for documentation
0004  *
0005  *
0006  *  \author Martin Grunewald
0007  *
0008  */
0009
0010 #include "FWCore/Common/interface/TriggerNames.h"
0011 #include "FWCore/Common/interface/TriggerResultsByName.h"
0012 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0013 #include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
0014 #include "HLTrigger/HLTcore/interface/HLTEventAnalyzerAOD.h"
0015
0016 #include <cassert>
0017
0018 //
0019 // constructor
0020 //
0021 HLTEventAnalyzerAOD::HLTEventAnalyzerAOD(const edm::ParameterSet& ps)
0022     : processName_(ps.getParameter<std::string>("processName")),
0023       triggerName_(ps.getParameter<std::string>("triggerName")),
0024       triggerResultsTag_(ps.getParameter<edm::InputTag>("triggerResults")),
0025       triggerResultsToken_(consumes<edm::TriggerResults>(triggerResultsTag_)),
0026       triggerEventTag_(ps.getParameter<edm::InputTag>("triggerEvent")),
0027       triggerEventToken_(consumes<trigger::TriggerEvent>(triggerEventTag_)),
0028       verbose_(ps.getParameter<bool>("verbose")),
0029       hltPrescaleProvider_(ps, consumesCollector(), *this) {
0030   LOG(logMsgType_) << logMsgType_ << " configuration:\n"
0031                    << "   ProcessName = " << processName_ << "\n"
0032                    << "   TriggerName = " << triggerName_ << "\n"
0033                    << "   TriggerResultsTag = " << triggerResultsTag_.encode() << "\n"
0034                    << "   TriggerEventTag = " << triggerEventTag_.encode();
0035 }
0036
0037 //
0038 // member functions
0039 //
0040 void HLTEventAnalyzerAOD::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0041   edm::ParameterSetDescription desc;
0042   desc.add<std::string>("processName", "HLT");
0043   desc.add<std::string>("triggerName", "@")
0044       ->setComment("name of trigger Path to consider (use \"@\" to consider all Paths)");
0045   desc.add<edm::InputTag>("triggerResults", edm::InputTag("TriggerResults", "", "HLT"));
0046   desc.add<edm::InputTag>("triggerEvent", edm::InputTag("hltTriggerSummaryAOD", "", "HLT"));
0047   desc.add<unsigned int>("stageL1Trigger", 1);
0048   desc.add<bool>("verbose", true)->setComment("enable verbose mode");
0049   descriptions.add("hltEventAnalyzerAODDefault", desc);
0050 }
0051
0052 void HLTEventAnalyzerAOD::beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {
0053   bool changed(true);
0054   if (hltPrescaleProvider_.init(iRun, iSetup, processName_, changed)) {
0055     HLTConfigProvider const& hltConfig = hltPrescaleProvider_.hltConfigProvider();
0056
0057     if (changed) {
0058       // check if trigger name in (new) config
0059       if (triggerName_ != "@") {  // "@" means: analyze all triggers in config
0060         const unsigned int n(hltConfig.size());
0061         const unsigned int triggerIndex(hltConfig.triggerIndex(triggerName_));
0062         if (triggerIndex >= n) {
0063           LOG(logMsgType_) << logMsgType_ << "::beginRun: TriggerName " << triggerName_
0064                            << " not available in (new) config!";
0065           LOG(logMsgType_) << "Available TriggerNames are:";
0066           hltConfig.dump("Triggers");
0067         }
0068       }
0069       // in verbose mode, print process info to stdout
0070       if (verbose_) {
0071         hltConfig.dump("ProcessName");
0072         hltConfig.dump("GlobalTag");
0073         hltConfig.dump("TableName");
0074         hltConfig.dump("Streams");
0075         hltConfig.dump("Datasets");
0076         hltConfig.dump("PrescaleTable");
0077         hltConfig.dump("ProcessPSet");
0078       }
0079     }
0080   } else {
0081     LOG(logMsgType_) << logMsgType_ << "::beginRun: config extraction failure with process name " << processName_;
0082   }
0083 }
0084
0085 void HLTEventAnalyzerAOD::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0086   // get event products
0087   iEvent.getByToken(triggerResultsToken_, triggerResultsHandle_);
0088   if (!triggerResultsHandle_.isValid()) {
0089     LOG(logMsgType_) << logMsgType_ << "::analyze: Error in getting TriggerResults product from Event!";
0090     return;
0091   }
0092   iEvent.getByToken(triggerEventToken_, triggerEventHandle_);
0093   if (!triggerEventHandle_.isValid()) {
0094     LOG(logMsgType_) << logMsgType_ << "::analyze: Error in getting TriggerEvent product from Event!";
0095     return;
0096   }
0097
0098   HLTConfigProvider const& hltConfig = hltPrescaleProvider_.hltConfigProvider();
0099
0100   // sanity check
0101   assert(triggerResultsHandle_->size() == hltConfig.size());
0102
0103   // analyze this event for the triggers requested
0104   if (triggerName_ == "@") {
0105     const unsigned int n(hltConfig.size());
0106     for (unsigned int i = 0; i != n; ++i) {
0107       analyzeTrigger(iEvent, iSetup, hltConfig.triggerName(i));
0108     }
0109   } else {
0110     analyzeTrigger(iEvent, iSetup, triggerName_);
0111   }
0112
0113   return;
0114 }
0115
0116 void HLTEventAnalyzerAOD::analyzeTrigger(const edm::Event& iEvent,
0117                                          const edm::EventSetup& iSetup,
0118                                          const std::string& triggerName) {
0119   HLTConfigProvider const& hltConfig = hltPrescaleProvider_.hltConfigProvider();
0120
0121   const unsigned int n(hltConfig.size());
0122   const unsigned int triggerIndex(hltConfig.triggerIndex(triggerName));
0123   assert(triggerIndex == iEvent.triggerNames(*triggerResultsHandle_).triggerIndex(triggerName));
0124
0125   // abort on invalid trigger name
0126   if (triggerIndex >= n) {
0127     LOG(logMsgType_) << logMsgType_ << "::analyzeTrigger: path " << triggerName << " - not found!";
0128     return;
0129   }
0130
0131   auto const prescales = hltPrescaleProvider_.prescaleValues<double>(iEvent, iSetup, triggerName);
0132
0133   LOG(logMsgType_) << logMsgType_ << "::analyzeTrigger: path " << triggerName << " [" << triggerIndex
0134                    << "] prescales L1T,HLT: " << prescales.first << "," << prescales.second;
0135
0136   auto const prescalesInDetail = hltPrescaleProvider_.prescaleValuesInDetail<double>(iEvent, iSetup, triggerName);
0137   {
0138     LOG logtmp(logMsgType_);
0139     logtmp << logMsgType_ << "::analyzeTrigger: path " << triggerName << " [" << triggerIndex
0140            << "]\n prescales L1T: " << prescalesInDetail.first.size();
0141     for (size_t idx = 0; idx < prescalesInDetail.first.size(); ++idx) {
0142       logtmp << " " << idx << ":" << prescalesInDetail.first[idx].first << "/" << prescalesInDetail.first[idx].second;
0143     }
0144     logtmp << "\n prescale HLT: " << prescalesInDetail.second;
0145   }
0146
0147   // results from TriggerResults product
0148   LOG(logMsgType_) << " Trigger path status:"
0149                    << " WasRun=" << triggerResultsHandle_->wasrun(triggerIndex)
0150                    << " Accept=" << triggerResultsHandle_->accept(triggerIndex)
0151                    << " Error=" << triggerResultsHandle_->error(triggerIndex);
0152
0153   // modules on this trigger path
0154   const unsigned int m(hltConfig.size(triggerIndex));
0155   const std::vector<std::string>& moduleLabels(hltConfig.moduleLabels(triggerIndex));
0156   assert(m == moduleLabels.size());
0157
0158   // skip empty Paths
0159   if (m == 0) {
0160     LOG(logMsgType_) << logMsgType_ << "::analyzeTrigger: path " << triggerName << " [" << triggerIndex
0161                      << "] is empty!";
0162     return;
0163   }
0164
0165   // index of last module executed in this Path
0166   const unsigned int moduleIndex(triggerResultsHandle_->index(triggerIndex));
0167   assert(moduleIndex < m);
0168
0169   LOG(logMsgType_) << " Last active module - label/type: " << moduleLabels[moduleIndex] << "/"
0170                    << hltConfig.moduleType(moduleLabels[moduleIndex]) << " [" << moduleIndex << " out of 0-" << (m - 1)
0171                    << " on this path]";
0172
0173   // results from TriggerEvent product
0174   // Attention: must look only for modules actually run in this path for this event!
0175   for (unsigned int j = 0; j <= moduleIndex; ++j) {
0176     const std::string& moduleLabel(moduleLabels[j]);
0177     const std::string moduleType(hltConfig.moduleType(moduleLabel));
0178
0179     // check whether the module is packed up in TriggerEvent product
0180     const unsigned int filterIndex(triggerEventHandle_->filterIndex(edm::InputTag(moduleLabel, "", processName_)));
0181     if (filterIndex < triggerEventHandle_->sizeFilters()) {
0182       LOG(logMsgType_) << " 'L3' filter in slot " << j << " - label/type " << moduleLabel << "/" << moduleType;
0183
0184       const trigger::Vids& VIDS(triggerEventHandle_->filterIds(filterIndex));
0185       const trigger::Keys& KEYS(triggerEventHandle_->filterKeys(filterIndex));
0186       const trigger::size_type nI(VIDS.size());
0187       const trigger::size_type nK(KEYS.size());
0188       assert(nI == nK);
0189
0190       LOG(logMsgType_) << "   " << nI << " accepted 'L3' objects found: ";
0191       const trigger::TriggerObjectCollection& TOC(triggerEventHandle_->getObjects());
0192       for (trigger::size_type idx = 0; idx < nI; ++idx) {
0193         const trigger::TriggerObject& TO(TOC[KEYS[idx]]);
0194         LOG(logMsgType_) << "   " << idx << " " << VIDS[idx] << "/" << KEYS[idx] << ": " << TO.id() << " " << TO.pt()
0195                          << " " << TO.eta() << " " << TO.phi() << " " << TO.mass();
0196       }
0197     }
0198   }
0199
0200   return;
0201 }