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/PatCandidates/interface/TauPFSpecific.h"
#include "DataFormats/PatCandidates/interface/TauCaloSpecific.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::RefVector<TauCollection> TauRefVector; 
}

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(); }
}

// 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);
      virtual ~Tau();

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

      // ---- methods for content embedding ----
      const reco::TrackRefVector & isolationTracks() const;
      reco::TrackRef leadTrack() const;
      const reco::TrackRefVector & signalTracks() const;    
      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);

      // ---- CaloTau accessors (getters only) ----
      bool isCaloTau() const { return !caloSpecific_.empty(); }
      const pat::tau::TauCaloSpecific & caloSpecific() const ;
      reco::CaloTauTagInfoRef caloTauTagInfoRef() const { return caloSpecific().CaloTauTagInfoRef_; }
      float leadTracksignedSipt() const { return caloSpecific().leadTracksignedSipt_; }
      float leadTrackHCAL3x3hitsEtSum() const { return caloSpecific().leadTrackHCAL3x3hitsEtSum_; }
      float leadTrackHCAL3x3hottesthitDEta() const { return caloSpecific().leadTrackHCAL3x3hottesthitDEta_; }
      float signalTracksInvariantMass() const { return caloSpecific().signalTracksInvariantMass_; }
      float TracksInvariantMass() const { return caloSpecific().TracksInvariantMass_; } 
      float isolationTracksPtSum() const { return caloSpecific().isolationTracksPtSum_; }
      float isolationECALhitsEtSum() const { return caloSpecific().isolationECALhitsEtSum_; }
      float maximumHCALhitEt() const { return caloSpecific().maximumHCALhitEt_; }

      // ---- PFTau accessors (getters only) ----
      bool isPFTau() const { return !pfSpecific_.empty(); }
      const pat::tau::TauPFSpecific & pfSpecific() const ;
      const pat::tau::TauPFEssential & pfEssential() const;
      const reco::PFJetRef & 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;

      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;}

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


      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_; }

      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:
      // ---- 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_;

      // ---- CaloTau specific variables  ----
      std::vector<pat::tau::TauCaloSpecific> caloSpecific_;

      // ---- 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_;


  };
}

#endif