TriggerAlgorithm.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_TriggerAlgorithm_h
#define DataFormats_PatCandidates_TriggerAlgorithm_h

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

#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/RefProd.h"
#include "DataFormats/Common/interface/RefVector.h"
#include "DataFormats/Common/interface/RefVectorIterator.h"

namespace pat {

  class TriggerAlgorithm {

    std::string name_;
    std::string alias_;
    std::string logic_;
    bool tech_;
    unsigned bit_;
    bool gtlResult_;
    unsigned prescale_;
    bool mask_;
    bool decisionBeforeMask_;
    bool decisionAfterMask_;
    std::vector<unsigned> conditionKeys_;

  public:

    TriggerAlgorithm();
    TriggerAlgorithm(const std::string& name);
    TriggerAlgorithm(const std::string& name,
                     const std::string& alias,
                     bool tech,
                     unsigned bit,
                     unsigned prescale,
                     bool mask,
                     bool decisionBeforeMask,
                     bool decisionAfterMask);  // for backward compatibility
    TriggerAlgorithm(const std::string& name,
                     const std::string& alias,
                     bool tech,
                     unsigned bit,
                     bool gtlResult,
                     unsigned prescale,
                     bool mask,
                     bool decisionBeforeMask,
                     bool decisionAfterMask);

    virtual ~TriggerAlgorithm(){};


    void setName(const std::string& name) { name_ = name; };
    void setAlias(const std::string& alias) { alias_ = alias; };
    void setLogicalExpression(const std::string& expression) { logic_ = expression; };
    void setTechTrigger(bool tech) { tech_ = tech; };
    void setBit(unsigned bit) { bit_ = bit; };
    void setGtlResult(bool gtlResult) { gtlResult_ = gtlResult; };
    void setPrescale(unsigned prescale) { prescale_ = prescale; };
    void setMask(bool mask) { mask_ = mask; };
    void setDecisionBeforeMask(bool decisionBeforeMask) { decisionBeforeMask_ = decisionBeforeMask; };
    void setDecisionAfterMas(bool decisionAfterMask) { decisionAfterMask_ = decisionAfterMask; };
    void addConditionKey(unsigned conditionKey) {
      if (!hasConditionKey(conditionKey))
        conditionKeys_.push_back(conditionKey);
    };
    const std::string& name() const { return name_; };
    const std::string& alias() const { return alias_; };
    const std::string& logicalExpression() const { return logic_; };
    bool techTrigger() const { return tech_; };
    unsigned bit() const { return bit_; };
    bool gtlResult() const { return gtlResult_; };
    unsigned prescale() const { return prescale_; };
    bool mask() const { return mask_; };
    bool decisionBeforeMask() const { return decisionBeforeMask_; };
    bool decisionAfterMask() const { return decisionAfterMask_; };
    bool decision() const { return decisionAfterMask(); };
    const std::vector<unsigned>& conditionKeys() const { return conditionKeys_; };
    bool hasConditionKey(unsigned conditionKey) const;
  };

  typedef std::vector<TriggerAlgorithm> TriggerAlgorithmCollection;
  typedef edm::Ref<TriggerAlgorithmCollection> TriggerAlgorithmRef;
  typedef edm::RefProd<TriggerAlgorithmCollection> TriggerAlgorithmRefProd;
  typedef edm::RefVector<TriggerAlgorithmCollection> TriggerAlgorithmRefVector;
  typedef edm::RefVectorIterator<TriggerAlgorithmCollection> TriggerAlgorithmRefVectorIterator;

}  // namespace pat

#endif