PatUtils/src/TriggerHelper.cc

0001 //
0002 //
0003
0004 #include "PhysicsTools/PatUtils/interface/TriggerHelper.h"
0005
0006 #include "DataFormats/Common/interface/AssociativeIterator.h"
0007
0008 using namespace pat;
0009 using namespace pat::helper;
0010
0011 // Methods
0012
0013 // Get a reference to the trigger objects matched to a certain physics object given by a reference for a certain matcher module
0014
0015 // ... by resulting association
0016 TriggerObjectRef TriggerMatchHelper::triggerMatchObject(const reco::CandidateBaseRef& candRef,
0017                                                         const TriggerObjectMatch* matchResult,
0018                                                         const edm::Event& event,
0019                                                         const TriggerEvent& triggerEvent) const {
0020   if (matchResult) {
0021     auto it = edm::makeAssociativeIterator<reco::CandidateBaseRef>(*matchResult, event);
0022     auto itEnd = it.end();
0023     while (it != itEnd) {
0024       if (it->first.isNonnull() && it->second.isNonnull() && it->second.isAvailable()) {
0025         if (it->first.id() == candRef.id() && it->first.key() == candRef.key()) {
0026           return TriggerObjectRef(it->second);
0027         }
0028       }
0029       ++it;
0030     }
0031   }
0032   return TriggerObjectRef();
0033 }
0034
0035 // ... by matcher module label
0036 TriggerObjectRef TriggerMatchHelper::triggerMatchObject(const reco::CandidateBaseRef& candRef,
0037                                                         const std::string& labelMatcher,
0038                                                         const edm::Event& event,
0039                                                         const TriggerEvent& triggerEvent) const {
0040   return triggerMatchObject(candRef, triggerEvent.triggerObjectMatchResult(labelMatcher), event, triggerEvent);
0041 }
0042
0043 // Get a table of references to all trigger objects matched to a certain physics object given by a reference
0044 TriggerObjectMatchMap TriggerMatchHelper::triggerMatchObjects(const reco::CandidateBaseRef& candRef,
0045                                                               const edm::Event& event,
0046                                                               const TriggerEvent& triggerEvent) const {
0047   TriggerObjectMatchMap theContainer;
0048   const std::vector<std::string> matchers(triggerEvent.triggerMatchers());
0049   for (size_t iMatch = 0; iMatch < matchers.size(); ++iMatch) {
0050     theContainer[matchers.at(iMatch)] = triggerMatchObject(candRef, matchers.at(iMatch), event, triggerEvent);
0051   }
0052   return theContainer;
0053 }
0054
0055 // Get a vector of references to the phyics objects matched to a certain trigger object given by a reference for a certain matcher module
0056
0057 // ... by resulting association
0058 reco::CandidateBaseRefVector TriggerMatchHelper::triggerMatchCandidates(const TriggerObjectRef& objectRef,
0059                                                                         const TriggerObjectMatch* matchResult,
0060                                                                         const edm::Event& event,
0061                                                                         const TriggerEvent& triggerEvent) const {
0062   reco::CandidateBaseRefVector theCands;
0063   if (matchResult) {
0064     auto it = edm::makeAssociativeIterator<reco::CandidateBaseRef>(*matchResult, event);
0065     auto itEnd = it.end();
0066     while (it != itEnd) {
0067       if (it->first.isNonnull() && it->second.isNonnull() && it->second.isAvailable()) {
0068         if (it->second == objectRef) {
0069           theCands.push_back(it->first);
0070         }
0071       }
0072       ++it;
0073     }
0074   }
0075   return theCands;
0076 }
0077
0078 // ... by matcher module label
0079 reco::CandidateBaseRefVector TriggerMatchHelper::triggerMatchCandidates(const TriggerObjectRef& objectRef,
0080                                                                         const std::string& labelMatcher,
0081                                                                         const edm::Event& event,
0082                                                                         const TriggerEvent& triggerEvent) const {
0083   return triggerMatchCandidates(objectRef, triggerEvent.triggerObjectMatchResult(labelMatcher), event, triggerEvent);
0084 }
0085
0086 // Get a vector of references to the phyics objects matched to a certain trigger object given by a collection and index for a certain matcher module
0087
0088 // ... by resulting association
0089 reco::CandidateBaseRefVector TriggerMatchHelper::triggerMatchCandidates(
0090     const edm::Handle<TriggerObjectCollection>& trigCollHandle,
0091     const size_t iTrig,
0092     const TriggerObjectMatch* matchResult,
0093     const edm::Event& event,
0094     const TriggerEvent& triggerEvent) const {
0095   return triggerMatchCandidates(TriggerObjectRef(trigCollHandle, iTrig), matchResult, event, triggerEvent);
0096 }
0097
0098 // ... by matcher module label
0099 reco::CandidateBaseRefVector TriggerMatchHelper::triggerMatchCandidates(
0100     const edm::Handle<TriggerObjectCollection>& trigCollHandle,
0101     const size_t iTrig,
0102     const std::string& labelMatcher,
0103     const edm::Event& event,
0104     const TriggerEvent& triggerEvent) const {
0105   return triggerMatchCandidates(TriggerObjectRef(trigCollHandle, iTrig),
0106                                 triggerEvent.triggerObjectMatchResult(labelMatcher),
0107                                 event,
0108                                 triggerEvent);
0109 }