TriggerObject.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_TriggerObject_h
#define DataFormats_PatCandidates_TriggerObject_h

// -*- C++ -*-
//
// Package:    PatCandidates
// Class:      pat::TriggerObject
//
//
#include "DataFormats/Candidate/interface/LeafCandidate.h"

#include <map>
#include <string>
#include <vector>
#include <algorithm>

#include "DataFormats/L1Trigger/interface/L1EmParticle.h"
#include "DataFormats/L1Trigger/interface/L1EmParticleFwd.h"
#include "DataFormats/L1Trigger/interface/L1EtMissParticle.h"
#include "DataFormats/L1Trigger/interface/L1EtMissParticleFwd.h"
#include "DataFormats/L1Trigger/interface/L1JetParticle.h"
#include "DataFormats/L1Trigger/interface/L1JetParticleFwd.h"
#include "DataFormats/L1Trigger/interface/L1MuonParticle.h"
#include "DataFormats/L1Trigger/interface/L1MuonParticleFwd.h"
#include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
#include "DataFormats/HLTReco/interface/TriggerObject.h"
#include "DataFormats/Common/interface/RefVectorIterator.h"
#include "DataFormats/Common/interface/Association.h"
#include "FWCore/Utilities/interface/InputTag.h"

namespace pat {

  class TriggerObject : public reco::LeafCandidate {

    std::string collection_;
    std::vector<trigger::TriggerObjectType> triggerObjectTypes_;
    reco::CandidateBaseRef refToOrig_;

  public:

    TriggerObject();
    TriggerObject(const trigger::TriggerObject& trigObj);
    TriggerObject(const reco::LeafCandidate& leafCand);
    TriggerObject(const reco::CandidateBaseRef& candRef);
    TriggerObject(const reco::Particle::LorentzVector& vec, int id = 0);
    TriggerObject(const reco::Particle::PolarLorentzVector& vec, int id = 0);

    ~TriggerObject() override{};


    void setCollection(const std::string& collName) { collection_ = collName; };
    void setCollection(const edm::InputTag& collName) { collection_ = collName.encode(); };
    void addTriggerObjectType(trigger::TriggerObjectType triggerObjectType) {
      if (!hasTriggerObjectType(triggerObjectType))
        triggerObjectTypes_.push_back(triggerObjectType);
    };
    void addTriggerObjectType(int triggerObjectType) {
      addTriggerObjectType(trigger::TriggerObjectType(triggerObjectType));
    };
    void addFilterId(trigger::TriggerObjectType triggerObjectType) {
      addTriggerObjectType(triggerObjectType);
    };  // for backward compatibility
    void addFilterId(int triggerObjectType) {
      addTriggerObjectType(trigger::TriggerObjectType(triggerObjectType));
    };  // for backward compatibility
    const std::string& collection() const { return collection_; };
    //       std::vector< trigger::TriggerObjectType > triggerObjectTypes() const { return triggerObjectTypes_; };
    //       std::vector< trigger::TriggerObjectType > filterIds()          const { return triggerObjectTypes(); }; // for backward compatibility
    std::vector<int> triggerObjectTypes() const;                          // for backward compatibility
    std::vector<int> filterIds() const { return triggerObjectTypes(); };  // for double backward compatibility
    virtual bool hasCollection(const std::string& collName) const;
    virtual bool hasCollection(const edm::InputTag& collName) const { return hasCollection(collName.encode()); };
    bool hasTriggerObjectType(trigger::TriggerObjectType triggerObjectType) const;
    bool hasTriggerObjectType(int triggerObjectType) const {
      return hasTriggerObjectType(trigger::TriggerObjectType(triggerObjectType));
    };
    bool hasFilterId(trigger::TriggerObjectType triggerObjectType) const {
      return hasTriggerObjectType(triggerObjectType);
    };  // for backward compatibility
    bool hasFilterId(int triggerObjectType) const {
      return hasTriggerObjectType(trigger::TriggerObjectType(triggerObjectType));
    };  // for backward compatibility


    const reco::CandidateBaseRef& origObjRef() const { return refToOrig_; };
    const reco::Candidate* origObjCand() const { return refToOrig_.get(); };
    const l1extra::L1EmParticleRef origL1EmRef() const;
    const L1GctEmCand* origL1GctEmCand() const {
      return origL1EmRef().isNonnull() ? origL1EmRef()->gctEmCand() : nullptr;
    };
    const l1extra::L1EtMissParticleRef origL1EtMissRef() const;
    const L1GctEtMiss* origL1GctEtMiss() const {
      return origL1EtMissRef().isNonnull() ? origL1EtMissRef()->gctEtMiss() : nullptr;
    };
    const L1GctEtTotal* origL1GctEtTotal() const {
      return origL1EtMissRef().isNonnull() ? origL1EtMissRef()->gctEtTotal() : nullptr;
    };
    const L1GctHtMiss* origL1GctHtMiss() const {
      return origL1EtMissRef().isNonnull() ? origL1EtMissRef()->gctHtMiss() : nullptr;
    };
    const L1GctEtHad* origL1GctEtHad() const {
      return origL1EtMissRef().isNonnull() ? origL1EtMissRef()->gctEtHad() : nullptr;
    };
    const l1extra::L1JetParticleRef origL1JetRef() const;
    const L1GctJetCand* origL1GctJetCand() const {
      return origL1JetRef().isNonnull() ? origL1JetRef()->gctJetCand() : nullptr;
    };
    const l1extra::L1MuonParticleRef origL1MuonRef() const;
    const L1MuGMTExtendedCand* origL1GmtMuonCand() const {
      return origL1MuonRef().isNonnull() ? &(origL1MuonRef()->gmtMuonCand()) : nullptr;
    };


    virtual bool coll(const std::string& collName) const { return hasCollection(collName); };
    bool type(trigger::TriggerObjectType triggerObjectType) const { return hasTriggerObjectType(triggerObjectType); };
    bool type(int triggerObjectType) const {
      return hasTriggerObjectType(trigger::TriggerObjectType(triggerObjectType));
    };
    bool id(trigger::TriggerObjectType triggerObjectType) const {
      return hasTriggerObjectType(triggerObjectType);
    };  // for backward compatibility
    bool id(int triggerObjectType) const {
      return hasTriggerObjectType(trigger::TriggerObjectType(triggerObjectType));
    };  // for backward compatibility
  };

  typedef std::vector<TriggerObject> TriggerObjectCollection;
  typedef edm::Ref<TriggerObjectCollection> TriggerObjectRef;
  typedef std::map<std::string, TriggerObjectRef> TriggerObjectMatchMap;
  typedef edm::RefProd<TriggerObjectCollection> TriggerObjectRefProd;
  typedef edm::RefVector<TriggerObjectCollection> TriggerObjectRefVector;
  typedef edm::RefVectorIterator<TriggerObjectCollection> TriggerObjectRefVectorIterator;
  typedef edm::Association<TriggerObjectCollection> TriggerObjectMatch;
  typedef edm::RefProd<TriggerObjectMatch> TriggerObjectMatchRefProd;
  typedef std::map<std::string, TriggerObjectMatchRefProd> TriggerObjectMatchContainer;

}  // namespace pat

#endif