TriggerEvent.h

Go to the documentation of this file.

#ifndef HLTReco_TriggerEvent_h
#define HLTReco_TriggerEvent_h

#include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
#include "DataFormats/HLTReco/interface/TriggerObject.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Common/interface/traits.h"
#include <string>
#include <vector>

namespace trigger
{

  class TriggerEvent : public edm::DoNotRecordParents {

  public:

    class TriggerFilterObject {
    public:
      std::string filterTag_;
      Vids filterIds_;
      Keys filterKeys_;
      TriggerFilterObject(): filterTag_(), filterIds_(), filterKeys_() {
    filterTag_=edm::InputTag().encode();
      }
      TriggerFilterObject(const edm::InputTag& filterTag): filterTag_(filterTag.encode()), filterIds_(), filterKeys_() { }
      TriggerFilterObject(const edm::InputTag& filterTag, const Vids& filterIds, const Keys& filterKeys): filterTag_(filterTag.encode()), filterIds_(filterIds), filterKeys_(filterKeys) { }
    };

  private:
    std::string usedProcessName_;
    std::vector<std::string> collectionTags_;
    Keys collectionKeys_;
    TriggerObjectCollection triggerObjects_;
    std::vector<TriggerFilterObject> triggerFilters_;

  public:
    TriggerEvent(): usedProcessName_(), collectionTags_(), collectionKeys_(), triggerObjects_(), triggerFilters_() { }
    TriggerEvent(const std::string& usedProcessName, trigger::size_type nc, trigger::size_type no, trigger::size_type nf):
      usedProcessName_(usedProcessName), 
      collectionTags_(),
      collectionKeys_(),
      triggerObjects_(), 
      triggerFilters_() 
    {
      collectionTags_.reserve(nc); collectionKeys_.reserve(nc);
      triggerObjects_.reserve(no); triggerFilters_.reserve(nf); 
    }

    void addObjects(const TriggerObjectCollection& triggerObjects) {triggerObjects_.insert(triggerObjects_.end(), triggerObjects.begin(), triggerObjects.end());}

    void addCollections(const std::vector<edm::InputTag>& collectionTags, const Keys& collectionKeys) {
      assert(collectionTags.size()==collectionKeys.size());
      const trigger::size_type n(collectionTags.size());
      for (trigger::size_type i=0; i!=n; ++i) {
    collectionTags_.push_back(collectionTags[i].encode());
      }
      collectionKeys_.insert(collectionKeys_.end(), collectionKeys.begin(), collectionKeys.end());
    }

    void addCollections(const std::vector<std::string>& collectionTags, const Keys& collectionKeys) {
      assert(collectionTags.size()==collectionKeys.size());
      collectionTags_.insert(collectionTags_.end(), collectionTags.begin(), collectionTags.end());
      collectionKeys_.insert(collectionKeys_.end(), collectionKeys.begin(), collectionKeys.end());
    }

    void addFilter(const edm::InputTag& filterTag, const Vids& filterIds, const Keys& filterKeys) {triggerFilters_.push_back(TriggerFilterObject(filterTag, filterIds, filterKeys));}

    const std::string& usedProcessName() const {return usedProcessName_;}
    const std::vector<std::string>& collectionTags() const {return collectionTags_;}
    const Keys& collectionKeys() const {return collectionKeys_;}
    const TriggerObjectCollection& getObjects() const {return triggerObjects_;}

    const edm::InputTag collectionTag(trigger::size_type index) const {return edm::InputTag(collectionTags_.at(index));}
    const std::string & collectionTagEncoded(trigger::size_type index) const {return collectionTags_.at(index);}
    trigger::size_type collectionKey(trigger::size_type index) const {return collectionKeys_.at(index);}
    const edm::InputTag filterTag(trigger::size_type index) const {return edm::InputTag(triggerFilters_.at(index).filterTag_);}
    const std::string & filterTagEncoded(trigger::size_type index) const {return triggerFilters_.at(index).filterTag_;}
    std::string filterLabel(trigger::size_type index) const {
        const std::string & tag = triggerFilters_.at(index).filterTag_;
        std::string::size_type idx = tag.find(':');
        return (idx == std::string::npos ? tag : tag.substr(0,idx));
    }
    const Vids& filterIds(trigger::size_type index) const {return triggerFilters_.at(index).filterIds_;}
    const Keys& filterKeys(trigger::size_type index) const {return triggerFilters_.at(index).filterKeys_;}

    trigger::size_type collectionIndex(const edm::InputTag& collectionTag) const {
      const std::string encodedCollectionTag(collectionTag.encode());
      const trigger::size_type n(collectionTags_.size());
      for (trigger::size_type i=0; i!=n; ++i) {
    if (encodedCollectionTag==collectionTags_[i]) {return i;}
      }
      return n;
    }
    trigger::size_type filterIndex(const edm::InputTag& filterTag) const {
      const std::string encodedFilterTag(filterTag.encode());
      const trigger::size_type n(triggerFilters_.size());
      for (trigger::size_type i=0; i!=n; ++i) {
    if (encodedFilterTag==triggerFilters_[i].filterTag_) {return i;}
      }
      return n;
    }

    trigger::size_type sizeCollections() const {return collectionTags_.size();}
    trigger::size_type sizeObjects() const {return triggerObjects_.size();}
    trigger::size_type sizeFilters() const {return triggerFilters_.size();}

  };

}

#endif