TriggerPath.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_TriggerPath_h
#define DataFormats_PatCandidates_TriggerPath_h
 
// -*- C++ -*-
//
// Package:    PatCandidates
// Class:      pat::TriggerPath
//
//
#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 {
 
  typedef std::pair<bool, std::string> L1Seed;
  typedef std::vector<L1Seed> L1SeedCollection;
 
  class TriggerPath {
 
    std::string name_;
    unsigned index_;
    unsigned prescale_;
    bool run_;
    bool accept_;
    bool error_;
    std::vector<std::string> modules_;
    std::vector<unsigned> filterIndices_;
    unsigned lastActiveFilterSlot_;
    unsigned l3Filters_;
    L1SeedCollection l1Seeds_;
 
  public:
 
    TriggerPath();
    TriggerPath(const std::string& name);
    TriggerPath(const std::string& name,
                unsigned index,
                unsigned prescale,
                bool run,
                bool accept,
                bool error,
                unsigned lastActiveFilterSlot,
                unsigned l3Filters = 0);
 
    virtual ~TriggerPath(){};
 
 
    void setName(const std::string& name) { name_ = name; };
    void setIndex(unsigned index) { index_ = index; };
    void setPrescale(unsigned prescale) { prescale_ = prescale; };
    void setRun(bool run) { run_ = run; };
    void setAccept(bool accept) { accept_ = accept; };
    void setError(bool error) { error_ = error; };
    void setLastActiveFilterSlot(unsigned lastActiveFilterSlot) { lastActiveFilterSlot_ = lastActiveFilterSlot; };
    void setL3Filters(unsigned l3Filters) { l3Filters_ = l3Filters; };
    void addModule(const std::string& name) { modules_.push_back(name); };
    void addFilterIndex(const unsigned index) { filterIndices_.push_back(index); };
    void addL1Seed(const L1Seed& seed) { l1Seeds_.push_back(seed); };
    void addL1Seed(bool decision, const std::string& expression) { l1Seeds_.push_back(L1Seed(decision, expression)); };
    const std::string& name() const { return name_; };
    unsigned index() const { return index_; };
    unsigned prescale() const { return prescale_; };
    bool wasRun() const { return run_; };
    bool wasAccept() const { return accept_; };
    bool wasError() const { return error_; };
    unsigned lastActiveFilterSlot() const { return lastActiveFilterSlot_; };
    unsigned l3Filters() const { return l3Filters_; };
    bool xTrigger() const { return (l3Filters_ > 2); };
    const std::vector<std::string>& modules() const { return modules_; };
    const std::vector<unsigned>& filterIndices() const { return filterIndices_; };
    int indexModule(const std::string& name) const;
    const L1SeedCollection& l1Seeds() const { return l1Seeds_; };
    std::vector<std::string> l1Seeds(const bool decision) const;
    std::vector<std::string> acceptedL1Seeds() const { return l1Seeds(true); };
    std::vector<std::string> failedL1Seeds() const { return l1Seeds(false); };
  };
 
  typedef std::vector<TriggerPath> TriggerPathCollection;
  typedef edm::Ref<TriggerPathCollection> TriggerPathRef;
  typedef edm::RefProd<TriggerPathCollection> TriggerPathRefProd;
  typedef edm::RefVector<TriggerPathCollection> TriggerPathRefVector;
  typedef edm::RefVectorIterator<TriggerPathCollection> TriggerPathRefVectorIterator;
 
}  // namespace pat
 
#endif