Tau.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_Tau_h
#define DataFormats_PatCandidates_Tau_h

#include "DataFormats/TauReco/interface/BaseTau.h"
#include "DataFormats/TauReco/interface/PFTauTransverseImpactParameter.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/PatCandidates/interface/Lepton.h"
#include "DataFormats/JetReco/interface/GenJetCollection.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"

#include "DataFormats/PatCandidates/interface/TauPFSpecific.h"
#include "DataFormats/PatCandidates/interface/TauJetCorrFactors.h"
#include "DataFormats/PatCandidates/interface/TauPFEssential.h"

#include "DataFormats/Common/interface/AtomicPtrCache.h"

// Define typedefs for convenience
namespace pat {
  class Tau;
  typedef std::vector<Tau> TauCollection;
  typedef edm::Ref<TauCollection> TauRef;
  typedef edm::RefProd<TauCollection> TauRefProd;
  typedef edm::RefVector<TauCollection> TauRefVector;
}  // namespace pat

namespace reco {
  std::ostream& operator<<(std::ostream& out, const pat::Tau& obj);
  //  bool sortByPt(const CandidatePtrVector::const_iterator &lhs, const CandidatePtrVector::const_iterator &rhs) { return (*lhs)->pt() < (*rhs)->pt(); }
}  // namespace reco

// Class definition
namespace pat {

  class PATTauSlimmer;

  class Tau : public Lepton<reco::BaseTau> {
    friend class PATTauProducer;

  public:
    typedef std::pair<std::string, float> IdPair;

    Tau();
    Tau(const reco::BaseTau& aTau);
    Tau(const edm::RefToBase<reco::BaseTau>& aTauRef);
    Tau(const edm::Ptr<reco::BaseTau>& aTauRef);
    ~Tau() override;

    Tau* clone() const override { return new Tau(*this); }

    // ---- methods for content embedding ----
    const reco::TrackRefVector& isolationTracks() const override;
    reco::TrackRef leadTrack() const override;
    const reco::TrackRefVector& signalTracks() const override;
    void embedIsolationTracks();
    void embedLeadTrack();
    void embedSignalTracks();
    void embedLeadPFCand();
    void embedLeadPFChargedHadrCand();
    void embedLeadPFNeutralCand();
    void embedSignalPFCands();
    void embedSignalPFChargedHadrCands();
    void embedSignalPFNeutralHadrCands();
    void embedSignalPFGammaCands();
    void embedIsolationPFCands();
    void embedIsolationPFChargedHadrCands();
    void embedIsolationPFNeutralHadrCands();
    void embedIsolationPFGammaCands();

    // ---- matched GenJet methods ----
    const reco::GenJet* genJet() const;
    void setGenJet(const reco::GenJetRef& ref);

    // ---- PFTau accessors (getters only) ----
    bool isPFTau() const { return !pfSpecific_.empty(); }
    const pat::tau::TauPFSpecific& pfSpecific() const;
    const pat::tau::TauPFEssential& pfEssential() const;
    const reco::JetBaseRef& pfJetRef() const { return pfSpecific().pfJetRef_; }
    reco::PFRecoTauChargedHadronRef leadTauChargedHadronCandidate() const;
    const reco::PFCandidatePtr leadPFChargedHadrCand() const;
    float leadPFChargedHadrCandsignedSipt() const { return pfSpecific().leadPFChargedHadrCandsignedSipt_; }
    const reco::PFCandidatePtr leadPFNeutralCand() const;
    const reco::PFCandidatePtr leadPFCand() const;
    const std::vector<reco::PFCandidatePtr>& signalPFCands() const;
    const std::vector<reco::PFCandidatePtr>& signalPFChargedHadrCands() const;
    const std::vector<reco::PFCandidatePtr>& signalPFNeutrHadrCands() const;
    const std::vector<reco::PFCandidatePtr>& signalPFGammaCands() const;
    const std::vector<reco::PFRecoTauChargedHadron>& signalTauChargedHadronCandidates() const;
    const std::vector<reco::RecoTauPiZero>& signalPiZeroCandidates() const;
    const std::vector<reco::PFCandidatePtr>& isolationPFCands() const;
    const std::vector<reco::PFCandidatePtr>& isolationPFChargedHadrCands() const;
    const std::vector<reco::PFCandidatePtr>& isolationPFNeutrHadrCands() const;
    const std::vector<reco::PFCandidatePtr>& isolationPFGammaCands() const;
    const std::vector<reco::PFRecoTauChargedHadron>& isolationTauChargedHadronCandidates() const;
    const std::vector<reco::RecoTauPiZero>& isolationPiZeroCandidates() const;
    float isolationPFChargedHadrCandsPtSum() const { return pfSpecific().isolationPFChargedHadrCandsPtSum_; }
    float isolationPFGammaCandsEtSum() const { return pfSpecific().isolationPFGammaCandsEtSum_; }
    float maximumHCALPFClusterEt() const { return pfSpecific().maximumHCALPFClusterEt_; }
    float emFraction() const { return pfSpecific().emFraction_; }
    float hcalTotOverPLead() const { return pfSpecific().hcalTotOverPLead_; }
    float hcalMaxOverPLead() const { return pfSpecific().hcalMaxOverPLead_; }
    float hcal3x3OverPLead() const { return pfSpecific().hcal3x3OverPLead_; }
    float ecalStripSumEOverPLead() const { return pfSpecific().ecalStripSumEOverPLead_; }
    float bremsRecoveryEOverPLead() const { return pfSpecific().bremsRecoveryEOverPLead_; }
    const reco::TrackRef& electronPreIDTrack() const { return pfSpecific().electronPreIDTrack_; }
    float electronPreIDOutput() const { return pfSpecific().electronPreIDOutput_; }
    bool electronPreIDDecision() const { return pfSpecific().electronPreIDDecision_; }
    float caloComp() const { return pfSpecific().caloComp_; }
    float segComp() const { return pfSpecific().segComp_; }
    bool muonDecision() const { return pfSpecific().muonDecision_; }

    const reco::CandidatePtr leadChargedHadrCand() const;
    const reco::CandidatePtr leadNeutralCand() const;
    const reco::CandidatePtr leadCand() const;
    bool ExistSignalCands() const;
    bool ExistIsolationCands() const;
    reco::CandidatePtrVector signalCands() const;
    reco::CandidatePtrVector signalChargedHadrCands() const;
    reco::CandidatePtrVector signalNeutrHadrCands() const;
    reco::CandidatePtrVector signalGammaCands() const;
    reco::CandidatePtrVector isolationCands() const;
    reco::CandidatePtrVector isolationChargedHadrCands() const;
    reco::CandidatePtrVector isolationNeutrHadrCands() const;
    reco::CandidatePtrVector isolationGammaCands() const;

    std::vector<reco::CandidatePtr> signalLostTracks() const;

    void setSignalChargedHadrCands(const reco::CandidatePtrVector& ptrs) { signalChargedHadrCandPtrs_ = ptrs; }
    void setSignalNeutralHadrCands(const reco::CandidatePtrVector& ptrs) { signalNeutralHadrCandPtrs_ = ptrs; }
    void setSignalGammaCands(const reco::CandidatePtrVector& ptrs) { signalGammaCandPtrs_ = ptrs; }
    void setIsolationChargedHadrCands(const reco::CandidatePtrVector& ptrs) { isolationChargedHadrCandPtrs_ = ptrs; }
    void setIsolationNeutralHadrCands(const reco::CandidatePtrVector& ptrs) { isolationNeutralHadrCandPtrs_ = ptrs; }
    void setIsolationGammaCands(const reco::CandidatePtrVector& ptrs) { isolationGammaCandPtrs_ = ptrs; }
    void setSignalLostTracks(const std::vector<reco::CandidatePtr>& ptrs);

    size_t numberOfSourceCandidatePtrs() const override;
    reco::CandidatePtr sourceCandidatePtr(size_type i) const override;

    const pat::tau::TauPFEssential::Point& dxy_PCA() const { return pfEssential().dxy_PCA_; }
    float dxy() const { return pfEssential().dxy_; }
    float dxy_error() const { return pfEssential().dxy_error_; }
    float dxy_Sig() const;
    const reco::VertexRef& primaryVertex() const { return pfEssential().pv_; }
    const pat::tau::TauPFEssential::Point& primaryVertexPos() const { return pfEssential().pvPos_; }
    const pat::tau::TauPFEssential::CovMatrix& primaryVertexCov() const { return pfEssential().pvCov_; }
    bool hasSecondaryVertex() const { return pfEssential().hasSV_; }
    const pat::tau::TauPFEssential::Vector& flightLength() const { return pfEssential().flightLength_; }
    float flightLengthSig() const { return pfEssential().flightLengthSig_; }
    pat::tau::TauPFEssential::CovMatrix flightLengthCov() const;
    const reco::VertexRef& secondaryVertex() const { return pfEssential().sv_; }
    const pat::tau::TauPFEssential::Point& secondaryVertexPos() const { return pfEssential().svPos_; }
    const pat::tau::TauPFEssential::CovMatrix& secondaryVertexCov() const { return pfEssential().svCov_; }
    float ip3d() const { return pfEssential().ip3d_; }
    float ip3d_error() const { return pfEssential().ip3d_error_; }
    float ip3d_Sig() const;

    float ecalEnergy() const { return pfEssential().ecalEnergy_; }
    float hcalEnergy() const { return pfEssential().hcalEnergy_; }
    float leadingTrackNormChi2() const { return pfEssential().leadingTrackNormChi2_; }

    float ecalEnergyLeadChargedHadrCand() const { return pfEssential().ecalEnergyLeadChargedHadrCand_; }
    float hcalEnergyLeadChargedHadrCand() const { return pfEssential().hcalEnergyLeadChargedHadrCand_; }
    float phiAtEcalEntrance() const { return pfEssential().phiAtEcalEntrance_; }
    float etaAtEcalEntrance() const { return pfEssential().etaAtEcalEntrance_; }
    float etaAtEcalEntranceLeadChargedCand() const { return pfEssential().etaAtEcalEntranceLeadChargedCand_; }
    float ptLeadChargedCand() const { return pfEssential().ptLeadChargedCand_; }
    float emFraction_MVA() const { return pfEssential().emFraction_; }

    reco::Candidate::LorentzVector p4Jet() const;
    float etaetaMoment() const;
    float phiphiMoment() const;
    float etaphiMoment() const;

    int decayMode() const { return pfEssential().decayMode_; }
    void setDecayMode(int);

    // ---- methods for tau ID ----
    float tauID(const std::string& name) const;
    float tauID(const char* name) const { return tauID(std::string(name)); }
    bool isTauIDAvailable(const std::string& name) const;
    const std::vector<IdPair>& tauIDs() const { return tauIDs_; }
    void setTauIDs(const std::vector<IdPair>& ids) { tauIDs_ = ids; }

    friend std::ostream& reco::operator<<(std::ostream& out, const Tau& obj);

    const std::vector<std::string> availableJECSets() const;
    // returns the available JEC Levels for a given jecSet
    const std::vector<std::string> availableJECLevels(const int& set = 0) const;
    // returns the available JEC Levels for a given jecSet
    const std::vector<std::string> availableJECLevels(const std::string& set) const {
      return availableJECLevels(jecSet(set));
    };
    bool jecSetsAvailable() const { return !jec_.empty(); }
    bool jecSetAvailable(const std::string& set) const { return (jecSet(set) >= 0); };
    bool jecSetAvailable(const unsigned int& set) const { return (set < jec_.size()); };
    std::string currentJECSet() const {
      return currentJECSet_ < jec_.size() ? jec_.at(currentJECSet_).jecSet() : std::string("ERROR");
    }
    std::string currentJECLevel() const {
      return currentJECSet_ < jec_.size() ? jec_.at(currentJECSet_).jecLevel(currentJECLevel_) : std::string("ERROR");
    }
    float jecFactor(const std::string& level, const std::string& set = "") const;
    float jecFactor(const unsigned int& level, const unsigned int& set = 0) const;
    Tau correctedTauJet(const std::string& level, const std::string& set = "") const;
    Tau correctedTauJet(const unsigned int& level, const unsigned int& set = 0) const;
    const LorentzVector& correctedP4(const std::string& level, const std::string& set = "") const {
      return correctedTauJet(level, set).p4();
    }
    const LorentzVector& correctedP4(const unsigned int& level, const unsigned int& set = 0) const {
      return correctedTauJet(level, set).p4();
    }

    friend class PATTauSlimmer;

  protected:
    int jecSet(const std::string& label) const;
    void currentJECSet(const unsigned int& set) { currentJECSet_ = set; };
    void currentJECLevel(const unsigned int& level) { currentJECLevel_ = level; };
    void addJECFactors(const TauJetCorrFactors& jec) { jec_.push_back(jec); };
    void initializeJEC(unsigned int level, const unsigned int set = 0);

  private:
    void initFromBaseTau(const reco::BaseTau& aTau);
    // ---- for content embedding ----
    bool embeddedIsolationTracks_;
    std::vector<reco::Track> isolationTracks_;
    edm::AtomicPtrCache<reco::TrackRefVector> isolationTracksTransientRefVector_;
    bool embeddedLeadTrack_;
    std::vector<reco::Track> leadTrack_;
    bool embeddedSignalTracks_;
    std::vector<reco::Track> signalTracks_;
    edm::AtomicPtrCache<reco::TrackRefVector> signalTracksTransientRefVector_;
    // specific for PFTau
    std::vector<reco::PFCandidate> leadPFCand_;
    bool embeddedLeadPFCand_;
    std::vector<reco::PFCandidate> leadPFChargedHadrCand_;
    bool embeddedLeadPFChargedHadrCand_;
    std::vector<reco::PFCandidate> leadPFNeutralCand_;
    bool embeddedLeadPFNeutralCand_;

    std::vector<reco::PFCandidate> signalPFCands_;
    bool embeddedSignalPFCands_;
    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > signalPFCandsTransientPtrs_;
    std::vector<reco::PFCandidate> signalPFChargedHadrCands_;
    bool embeddedSignalPFChargedHadrCands_;
    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > signalPFChargedHadrCandsTransientPtrs_;
    std::vector<reco::PFCandidate> signalPFNeutralHadrCands_;
    bool embeddedSignalPFNeutralHadrCands_;
    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > signalPFNeutralHadrCandsTransientPtrs_;
    std::vector<reco::PFCandidate> signalPFGammaCands_;
    bool embeddedSignalPFGammaCands_;
    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > signalPFGammaCandsTransientPtrs_;
    std::vector<reco::PFCandidate> isolationPFCands_;
    bool embeddedIsolationPFCands_;
    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > isolationPFCandsTransientPtrs_;
    std::vector<reco::PFCandidate> isolationPFChargedHadrCands_;
    bool embeddedIsolationPFChargedHadrCands_;
    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > isolationPFChargedHadrCandsTransientPtrs_;
    std::vector<reco::PFCandidate> isolationPFNeutralHadrCands_;
    bool embeddedIsolationPFNeutralHadrCands_;
    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > isolationPFNeutralHadrCandsTransientPtrs_;
    std::vector<reco::PFCandidate> isolationPFGammaCands_;
    bool embeddedIsolationPFGammaCands_;
    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > isolationPFGammaCandsTransientPtrs_;

    // ---- matched GenJet holder ----
    std::vector<reco::GenJet> genJet_;

    // ---- tau ID's holder ----
    std::vector<IdPair> tauIDs_;

    // ---- PFTau specific variables  ----
    std::vector<pat::tau::TauPFSpecific> pfSpecific_;

    // ---- energy scale correction factors ----
    // energy scale correction factors; the string carries a potential label if
    // more then one set of correction factors is embedded. The label corresponds
    // to the label of the jetCorrFactors module that has been embedded.
    std::vector<pat::TauJetCorrFactors> jec_;
    // currently applied set of jet energy correction factors (i.e. the index in
    // jetEnergyCorrections_)
    unsigned int currentJECSet_;
    // currently applied jet energy correction level
    unsigned int currentJECLevel_;

    // ---- references to packed pf candidates -----
    reco::CandidatePtrVector signalChargedHadrCandPtrs_;
    reco::CandidatePtrVector signalNeutralHadrCandPtrs_;
    reco::CandidatePtrVector signalGammaCandPtrs_;

    reco::CandidatePtrVector isolationChargedHadrCandPtrs_;
    reco::CandidatePtrVector isolationNeutralHadrCandPtrs_;
    reco::CandidatePtrVector isolationGammaCandPtrs_;

    // -- essential info to keep

    std::vector<pat::tau::TauPFEssential> pfEssential_;
  };
}  // namespace pat

#endif