TriggerEvent.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_TriggerEvent_h
#define DataFormats_PatCandidates_TriggerEvent_h
 
// -*- C++ -*-
//
// Package:    PatCandidates
// Class:      pat::TriggerEvent
//
//
#include "DataFormats/PatCandidates/interface/TriggerAlgorithm.h"
#include "DataFormats/PatCandidates/interface/TriggerCondition.h"
#include "DataFormats/PatCandidates/interface/TriggerPath.h"
#include "DataFormats/PatCandidates/interface/TriggerFilter.h"
#include "DataFormats/PatCandidates/interface/TriggerObject.h"
 
#include <string>
#include <vector>
 
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/OrphanHandle.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include <cstdint>
 
namespace pat {
 
  class TriggerEvent {
 
    std::string nameL1Menu_;
    std::string nameHltTable_;
    bool run_;
    bool accept_;
    bool error_;
    bool physDecl_;
    uint32_t lhcFill_;
    uint16_t beamMode_;
    uint16_t beamMomentum_;
    uint32_t intensityBeam1_;
    uint32_t intensityBeam2_;
    uint16_t bstMasterStatus_;
    uint32_t turnCount_;
    float bCurrentStart_;
    float bCurrentStop_;
    float bCurrentAvg_;
 
    TriggerAlgorithmRefProd algorithms_;
    TriggerConditionRefProd conditions_;
    TriggerPathRefProd paths_;
    TriggerFilterRefProd filters_;
    TriggerObjectRefProd objects_;
    TriggerObjectMatchContainer objectMatchResults_;
 
  public:
 
    TriggerEvent();
    TriggerEvent(
        const std::string& nameHltTable, bool run = true, bool accept = true, bool error = false, bool physDecl = true);
    TriggerEvent(const std::string& nameL1Menu,
                 const std::string& nameHltTable,
                 bool run = true,
                 bool accept = true,
                 bool error = false,
                 bool physDecl = true);
 
    virtual ~TriggerEvent(){};
 
 
    void setNameL1Menu(const std::string& name) { nameL1Menu_ = name; };
    void setNameHltTable(const std::string& name) { nameHltTable_ = name; };
    void setRun(bool run) { run_ = run; };
    void setAccept(bool accept) { accept_ = accept; };
    void setError(bool error) { error_ = error; };
    void setPhysDecl(bool physDecl) { physDecl_ = physDecl; };
    void setLhcFill(uint32_t lhcFill) { lhcFill_ = lhcFill; };
    void setBeamMode(uint16_t beamMode) { beamMode_ = beamMode; };
    void setBeamMomentum(uint16_t beamMomentum) { beamMomentum_ = beamMomentum; };
    void setIntensityBeam1(uint32_t intensityBeam1) { intensityBeam1_ = intensityBeam1; };
    void setIntensityBeam2(uint32_t intensityBeam2) { intensityBeam2_ = intensityBeam2; };
    void setBstMasterStatus(uint16_t bstMasterStatus) { bstMasterStatus_ = bstMasterStatus; };
    void setTurnCount(uint32_t turnCount) { turnCount_ = turnCount; };
    void setBCurrentStart(float bCurrentStart) { bCurrentStart_ = bCurrentStart; };
    void setBCurrentStop(float bCurrentStop) { bCurrentStop_ = bCurrentStop; };
    void setBCurrentAvg(float bCurrentAvg) { bCurrentAvg_ = bCurrentAvg; };
    const std::string& nameL1Menu() const { return nameL1Menu_; };
    const std::string& nameHltTable() const { return nameHltTable_; };
    bool wasRun() const { return run_; };
    bool wasAccept() const { return accept_; };
    bool wasError() const { return error_; };
    bool wasPhysDecl() const { return physDecl_; };
    uint32_t lhcFill() const { return lhcFill_; };
    uint16_t beamMode() const { return beamMode_; };
    uint16_t beamMomentum() const { return beamMomentum_; };
    uint32_t intensityBeam1() const { return intensityBeam1_; };
    uint32_t intensityBeam2() const { return intensityBeam2_; };
    uint16_t bstMasterStatus() const { return bstMasterStatus_; };
    uint32_t turnCount() const { return turnCount_; };
    float bCurrentStart() const { return bCurrentStart_; };
    float bCurrentStop() const { return bCurrentStop_; };
    float bCurrentAvg() const { return bCurrentAvg_; };
 
    void setAlgorithms(const edm::Handle<TriggerAlgorithmCollection>& handleTriggerAlgorithms) {
      algorithms_ = TriggerAlgorithmRefProd(handleTriggerAlgorithms);
    };
    const TriggerAlgorithmCollection* algorithms() const { return algorithms_.get(); };
    const TriggerAlgorithmRefVector algorithmRefs() const;
    const TriggerAlgorithm* algorithm(const std::string& nameAlgorithm) const;
    const TriggerAlgorithmRef algorithmRef(const std::string& nameAlgorithm) const;
    std::string nameAlgorithm(const unsigned bitAlgorithm, const bool techAlgorithm = true) const;
    unsigned indexAlgorithm(const std::string& nameAlgorithm) const;
    TriggerAlgorithmRefVector acceptedAlgorithms() const;
    TriggerAlgorithmRefVector acceptedAlgorithmsGtl() const;
    TriggerAlgorithmRefVector techAlgorithms() const;
    TriggerAlgorithmRefVector acceptedTechAlgorithms() const;
    TriggerAlgorithmRefVector acceptedTechAlgorithmsGtl() const;
    TriggerAlgorithmRefVector physAlgorithms() const;
    TriggerAlgorithmRefVector acceptedPhysAlgorithms() const;
    TriggerAlgorithmRefVector acceptedPhysAlgorithmsGtl() const;
 
    void setConditions(const edm::Handle<TriggerConditionCollection>& handleTriggerConditions) {
      conditions_ = TriggerConditionRefProd(handleTriggerConditions);
    };
    const TriggerConditionCollection* conditions() const { return conditions_.get(); };
    const TriggerConditionRefVector conditionRefs() const;
    const TriggerCondition* condition(const std::string& nameCondition) const;
    const TriggerConditionRef conditionRef(const std::string& nameCondition) const;
    unsigned indexCondition(const std::string& nameCondition) const;
    TriggerConditionRefVector acceptedConditions() const;
 
    void setPaths(const edm::Handle<TriggerPathCollection>& handleTriggerPaths) {
      paths_ = TriggerPathRefProd(handleTriggerPaths);
    };
    const TriggerPathCollection* paths() const { return paths_.get(); };
    const TriggerPathRefVector pathRefs() const;
    const TriggerPath* path(const std::string& namePath) const;
    const TriggerPathRef pathRef(const std::string& namePath) const;
    unsigned indexPath(const std::string& namePath) const;
    TriggerPathRefVector acceptedPaths() const;
 
    void setFilters(const edm::Handle<TriggerFilterCollection>& handleTriggerFilters) {
      filters_ = TriggerFilterRefProd(handleTriggerFilters);
    };
    const TriggerFilterCollection* filters() const { return filters_.get(); };
    const TriggerFilterRefVector filterRefs() const;
    const TriggerFilter* filter(const std::string& labelFilter) const;
    const TriggerFilterRef filterRef(const std::string& labelFilter) const;
    unsigned indexFilter(const std::string& labelFilter) const;
    TriggerFilterRefVector acceptedFilters() const;
 
    void setObjects(const edm::Handle<TriggerObjectCollection>& handleTriggerObjects) {
      objects_ = TriggerObjectRefProd(handleTriggerObjects);
    };
    const TriggerObjectCollection* objects() const { return objects_.get(); };
    const TriggerObjectRefVector objectRefs() const;
    TriggerObjectRefVector objects(trigger::TriggerObjectType triggerObjectType) const;
    TriggerObjectRefVector objects(int triggerObjectType) const {
      return objects(trigger::TriggerObjectType(triggerObjectType));
    };  // for backward compatibility
 
    TriggerConditionRefVector algorithmConditions(const std::string& nameAlgorithm) const;
    bool conditionInAlgorithm(const TriggerConditionRef& conditionRef, const std::string& nameAlgorithm) const;
    TriggerAlgorithmRefVector conditionAlgorithms(const TriggerConditionRef& conditionRef) const;
    std::vector<std::string> conditionCollections(const std::string& nameAlgorithm) const;
    TriggerObjectRefVector conditionObjects(const std::string& nameCondition) const;
    bool objectInCondition(const TriggerObjectRef& objectRef, const std::string& nameCondition) const;
    TriggerConditionRefVector objectConditions(const TriggerObjectRef& objectRef) const;
    TriggerObjectRefVector algorithmObjects(const std::string& nameAlgorithm) const;
    bool objectInAlgorithm(const TriggerObjectRef& objectRef, const std::string& nameAlgorithm) const;
    TriggerAlgorithmRefVector objectAlgorithms(const TriggerObjectRef& objectRef) const;
 
    TriggerFilterRefVector pathModules(const std::string& namePath, bool all = true) const;
    TriggerFilterRefVector pathFilters(const std::string& namePath, bool firing = true) const;
    bool filterInPath(const TriggerFilterRef& filterRef, const std::string& namePath, bool firing = true) const;
    TriggerPathRefVector filterPaths(const TriggerFilterRef& filterRef, bool firing = true) const;
    std::vector<std::string> filterCollections(const std::string& labelFilter) const;
    TriggerObjectRefVector filterObjects(const std::string& labelFilter) const;
    bool objectInFilter(const TriggerObjectRef& objectRef, const std::string& labelFilter) const;
    TriggerFilterRefVector objectFilters(const TriggerObjectRef& objectRef, bool firing = true) const;
    TriggerObjectRefVector pathObjects(const std::string& namePath, bool firing = true) const;
    bool objectInPath(const TriggerObjectRef& objectRef, const std::string& namePath, bool firing = true) const;
    TriggerPathRefVector objectPaths(const TriggerObjectRef& objectRef, bool firing = true) const;
 
    bool addObjectMatchResult(const TriggerObjectMatchRefProd& trigMatches, const std::string& labelMatcher);
    bool addObjectMatchResult(const edm::Handle<TriggerObjectMatch>& trigMatches, const std::string& labelMatcher) {
      return addObjectMatchResult(TriggerObjectMatchRefProd(trigMatches), labelMatcher);
    };
    bool addObjectMatchResult(const edm::OrphanHandle<TriggerObjectMatch>& trigMatches,
                              const std::string& labelMatcher) {
      return addObjectMatchResult(TriggerObjectMatchRefProd(trigMatches), labelMatcher);
    };
    std::vector<std::string> triggerMatchers() const;
    const TriggerObjectMatchContainer* triggerObjectMatchResults() const { return &objectMatchResults_; };
    const TriggerObjectMatch* triggerObjectMatchResult(const std::string& labelMatcher) const;
 
  };
 
}  // namespace pat
 
#endif