TriggerCondition.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_TriggerCondition_h
#define DataFormats_PatCandidates_TriggerCondition_h

// -*- C++ -*-
//
// Package:    PatCandidates
// Class:      pat::TriggerCondition
//
//
#include <string>
#include <vector>

#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/RefProd.h"
#include "DataFormats/Common/interface/RefVector.h"
#include "DataFormats/Common/interface/RefVectorIterator.h"
#include "CondFormats/L1TObjects/interface/L1GtFwd.h"
#include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"

namespace pat {

  class TriggerCondition {

    std::string name_;
    bool accept_;
    L1GtConditionCategory category_;
    L1GtConditionType type_;
    std::vector<trigger::TriggerObjectType> triggerObjectTypes_;
    std::vector<unsigned> objectKeys_;

  public:

    TriggerCondition();
    TriggerCondition(const std::string& name);
    TriggerCondition(const std::string& name, bool accept);

    virtual ~TriggerCondition(){};


    void setName(const std::string& name) { name_ = name; };
    void setAccept(bool accept) { accept_ = accept; };
    void setCategory(L1GtConditionCategory category) { category_ = category; };
    void setCategory(int category) { category_ = L1GtConditionCategory(category); };
    void setType(L1GtConditionType type) { type_ = type; };
    void setType(int type) { type_ = L1GtConditionType(type); };
    void addTriggerObjectType(trigger::TriggerObjectType triggerObjectType) {
      triggerObjectTypes_.push_back(triggerObjectType);
    };  // explicitely NOT checking for existence
    void addTriggerObjectType(int triggerObjectType) {
      addTriggerObjectType(trigger::TriggerObjectType(triggerObjectType));
    };
    void addObjectKey(unsigned objectKey) {
      if (!hasObjectKey(objectKey))
        objectKeys_.push_back(objectKey);
    };
    const std::string& name() const { return name_; };
    bool wasAccept() const { return accept_; };
    int category() const { return int(category_); };
    int type() const { return int(type_); };
    std::vector<int> triggerObjectTypes() const;
    bool hasTriggerObjectType(trigger::TriggerObjectType triggerObjectType) const;
    bool hasTriggerObjectType(int triggerObjectType) const {
      return hasTriggerObjectType(trigger::TriggerObjectType(triggerObjectType));
    };
    const std::vector<unsigned>& objectKeys() const { return objectKeys_; };
    bool hasObjectKey(unsigned objectKey) const;
  };

  typedef std::vector<TriggerCondition> TriggerConditionCollection;
  typedef edm::Ref<TriggerConditionCollection> TriggerConditionRef;
  typedef edm::RefProd<TriggerConditionCollection> TriggerConditionRefProd;
  typedef edm::RefVector<TriggerConditionCollection> TriggerConditionRefVector;
  typedef edm::RefVectorIterator<TriggerConditionCollection> TriggerConditionRefVectorIterator;

}  // namespace pat

#endif