HLTReco/interface/TriggerEvent.h

0001 #ifndef HLTReco_TriggerEvent_h
0002 #define HLTReco_TriggerEvent_h
0003
0004 /** \class trigger::TriggerEvent
0005  *
0006  *  The single EDProduct to be saved for each event (AOD case)
0007  *  describing the (HLT) trigger table
0008  *
0009  *
0010  *  \author Martin Grunewald
0011  *
0012  */
0013
0014 #include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
0015 #include "DataFormats/HLTReco/interface/TriggerObject.h"
0016 #include "FWCore/Utilities/interface/InputTag.h"
0017 #include "DataFormats/Common/interface/traits.h"
0018 #include <string>
0019 #include <string_view>
0020 #include <vector>
0021 #include <cassert>
0022
0023 namespace trigger {
0024
0025   /// The single EDProduct to be saved for each event (AOD case)
0026   class TriggerEvent : public edm::DoNotRecordParents {
0027   public:
0028     /// Helper class: recording trigger objects firing a single filter
0029     class TriggerFilterObject {
0030     public:
0031       /// encoded InputTag of filter product
0032       std::string filterTag_;
0033       /// physics object type as per filter
0034       Vids filterIds_;
0035       /// indices pointing into collection of unique TriggerObjects
0036       Keys filterKeys_;
0037       /// constructors
0038       TriggerFilterObject() : filterTag_(), filterIds_(), filterKeys_() { filterTag_ = edm::InputTag().encode(); }
0039       TriggerFilterObject(const edm::InputTag& filterTag)
0040           : filterTag_(filterTag.encode()), filterIds_(), filterKeys_() {}
0041       TriggerFilterObject(const edm::InputTag& filterTag, const Vids& filterIds, const Keys& filterKeys)
0042           : filterTag_(filterTag.encode()), filterIds_(filterIds), filterKeys_(filterKeys) {}
0043     };
0044
0045     /// data members
0046   private:
0047     /// processName used to select products packed up
0048     std::string usedProcessName_;
0049     /// Input tags of packed up collections
0050     std::vector<std::string> collectionTags_;
0051     /// 1-past-end indices into linearised vector
0052     Keys collectionKeys_;
0053     /// collection of all unique physics objects (linearised vector)
0054     TriggerObjectCollection triggerObjects_;
0055     /// collection of all TriggerFilterObjects
0056     std::vector<TriggerFilterObject> triggerFilters_;
0057
0058     ///methods
0059   public:
0060     /// constructors
0061     TriggerEvent() : usedProcessName_(), collectionTags_(), collectionKeys_(), triggerObjects_(), triggerFilters_() {}
0062     TriggerEvent(const std::string& usedProcessName, trigger::size_type nc, trigger::size_type no, trigger::size_type nf)
0063         : usedProcessName_(usedProcessName),
0064           collectionTags_(),
0065           collectionKeys_(),
0066           triggerObjects_(),
0067           triggerFilters_() {
0068       collectionTags_.reserve(nc);
0069       collectionKeys_.reserve(nc);
0070       triggerObjects_.reserve(no);
0071       triggerFilters_.reserve(nf);
0072     }
0073
0074     /// setters
0075     void addObjects(const TriggerObjectCollection& triggerObjects) {
0076       triggerObjects_.insert(triggerObjects_.end(), triggerObjects.begin(), triggerObjects.end());
0077     }
0078
0079     void addCollections(const std::vector<edm::InputTag>& collectionTags, const Keys& collectionKeys) {
0080       assert(collectionTags.size() == collectionKeys.size());
0081       const trigger::size_type n(collectionTags.size());
0082       for (trigger::size_type i = 0; i != n; ++i) {
0083         collectionTags_.push_back(collectionTags[i].encode());
0084       }
0085       collectionKeys_.insert(collectionKeys_.end(), collectionKeys.begin(), collectionKeys.end());
0086     }
0087
0088     void addCollections(const std::vector<std::string>& collectionTags, const Keys& collectionKeys) {
0089       assert(collectionTags.size() == collectionKeys.size());
0090       collectionTags_.insert(collectionTags_.end(), collectionTags.begin(), collectionTags.end());
0091       collectionKeys_.insert(collectionKeys_.end(), collectionKeys.begin(), collectionKeys.end());
0092     }
0093
0094     void addFilter(const edm::InputTag& filterTag, const Vids& filterIds, const Keys& filterKeys) {
0095       triggerFilters_.push_back(TriggerFilterObject(filterTag, filterIds, filterKeys));
0096     }
0097
0098     /// getters
0099     const std::string& usedProcessName() const { return usedProcessName_; }
0100     const std::vector<std::string>& collectionTags() const { return collectionTags_; }
0101     const Keys& collectionKeys() const { return collectionKeys_; }
0102     const TriggerObjectCollection& getObjects() const { return triggerObjects_; }
0103
0104     const edm::InputTag collectionTag(trigger::size_type index) const {
0105       return edm::InputTag(collectionTags_.at(index));
0106     }
0107     const std::string& collectionTagEncoded(trigger::size_type index) const { return collectionTags_.at(index); }
0108     trigger::size_type collectionKey(trigger::size_type index) const { return collectionKeys_.at(index); }
0109     const edm::InputTag filterTag(trigger::size_type index) const {
0110       return edm::InputTag(triggerFilters_.at(index).filterTag_);
0111     }
0112     const std::string& filterTagEncoded(trigger::size_type index) const { return triggerFilters_.at(index).filterTag_; }
0113     std::string_view filterLabel(trigger::size_type index) const {
0114       std::string_view tag = triggerFilters_.at(index).filterTag_;
0115       auto const idx = tag.find(':');
0116       return (idx == tag.npos ? tag : tag.substr(0, idx));
0117     }
0118     const Vids& filterIds(trigger::size_type index) const { return triggerFilters_.at(index).filterIds_; }
0119     const Keys& filterKeys(trigger::size_type index) const { return triggerFilters_.at(index).filterKeys_; }
0120
0121     /// find index of collection from collection tag
0122     trigger::size_type collectionIndex(const edm::InputTag& collectionTag) const {
0123       const std::string encodedCollectionTag(collectionTag.encode());
0124       const trigger::size_type n(collectionTags_.size());
0125       for (trigger::size_type i = 0; i != n; ++i) {
0126         if (encodedCollectionTag == collectionTags_[i]) {
0127           return i;
0128         }
0129       }
0130       return n;
0131     }
0132     /// find index of filter in data-member vector from filter tag
0133     trigger::size_type filterIndex(const edm::InputTag& filterTag) const {
0134       const std::string encodedFilterTag(filterTag.encode());
0135       const trigger::size_type n(triggerFilters_.size());
0136       for (trigger::size_type i = 0; i != n; ++i) {
0137         if (encodedFilterTag == triggerFilters_[i].filterTag_) {
0138           return i;
0139         }
0140       }
0141       return n;
0142     }
0143
0144     /// other
0145     trigger::size_type sizeCollections() const { return collectionTags_.size(); }
0146     trigger::size_type sizeObjects() const { return triggerObjects_.size(); }
0147     trigger::size_type sizeFilters() const { return triggerFilters_.size(); }
0148   };
0149
0150 }  // namespace trigger
0151
0152 #endif