Tau.h

Go to the documentation of this file.

//
// $Id: Tau.h,v 1.28 2011/03/11 17:45:34 veelken Exp $
//

#ifndef DataFormats_PatCandidates_Tau_h
#define DataFormats_PatCandidates_Tau_h

#include "DataFormats/TauReco/interface/BaseTau.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/PatCandidates/interface/Lepton.h"
#include "DataFormats/JetReco/interface/GenJetCollection.h"

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

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

// Class definition
namespace pat {

  class Tau : public Lepton<reco::BaseTau> {

    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 reco::PFJetRef & pfJetRef() const { return pfSpecific().pfJetRef_; }
      const reco::PFCandidateRef leadPFChargedHadrCand() const;
      float leadPFChargedHadrCandsignedSipt() const { return pfSpecific().leadPFChargedHadrCandsignedSipt_; }
      const reco::PFCandidateRef leadPFNeutralCand() const;
      const reco::PFCandidateRef leadPFCand() const;
      const reco::PFCandidateRefVector & signalPFCands() const;
      const reco::PFCandidateRefVector & signalPFChargedHadrCands() const;
      const reco::PFCandidateRefVector & signalPFNeutrHadrCands() const;
      const reco::PFCandidateRefVector & signalPFGammaCands() const;
      const reco::PFCandidateRefVector & isolationPFCands() const;
      const reco::PFCandidateRefVector & isolationPFChargedHadrCands() const;
      const reco::PFCandidateRefVector & isolationPFNeutrHadrCands() const;
      const reco::PFCandidateRefVector & isolationPFGammaCands() 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_; }

      float etaetaMoment() const;
      float phiphiMoment() const;
      float etaphiMoment() const;

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

      // ---- methods for tau ID ----
      float tauID(const std::string & name) const;
      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);

    protected:

      // ---- for content embedding ----
      bool embeddedIsolationTracks_;
      std::vector<reco::Track> isolationTracks_;
      mutable reco::TrackRefVector isolationTracksTransientRefVector_;
      mutable edm::BoolCache       isolationTracksTransientRefVectorFixed_;
      bool embeddedLeadTrack_;
      std::vector<reco::Track> leadTrack_;
      bool embeddedSignalTracks_;
      std::vector<reco::Track> signalTracks_;
      mutable reco::TrackRefVector signalTracksTransientRefVector_;
      mutable edm::BoolCache       signalTracksTransientRefVectorFixed_;
      // 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_;
      mutable reco::PFCandidateRefVector signalPFCandsTransientRefVector_;
      mutable edm::BoolCache signalPFCandsRefVectorFixed_;
      std::vector<reco::PFCandidate> signalPFChargedHadrCands_;
      bool embeddedSignalPFChargedHadrCands_;
      mutable reco::PFCandidateRefVector signalPFChargedHadrCandsTransientRefVector_;
      mutable edm::BoolCache signalPFChargedHadrCandsRefVectorFixed_;
      std::vector<reco::PFCandidate> signalPFNeutralHadrCands_;
      bool embeddedSignalPFNeutralHadrCands_;
      mutable reco::PFCandidateRefVector signalPFNeutralHadrCandsTransientRefVector_;
      mutable edm::BoolCache signalPFNeutralHadrCandsRefVectorFixed_;
      std::vector<reco::PFCandidate> signalPFGammaCands_;
      bool embeddedSignalPFGammaCands_;
      mutable reco::PFCandidateRefVector signalPFGammaCandsTransientRefVector_;
      mutable edm::BoolCache signalPFGammaCandsRefVectorFixed_;
      std::vector<reco::PFCandidate> isolationPFCands_;
      bool embeddedIsolationPFCands_;
      mutable reco::PFCandidateRefVector isolationPFCandsTransientRefVector_;
      mutable edm::BoolCache isolationPFCandsRefVectorFixed_;
      std::vector<reco::PFCandidate> isolationPFChargedHadrCands_;
      bool embeddedIsolationPFChargedHadrCands_;
      mutable reco::PFCandidateRefVector isolationPFChargedHadrCandsTransientRefVector_;
      mutable edm::BoolCache isolationPFChargedHadrCandsRefVectorFixed_;
      std::vector<reco::PFCandidate> isolationPFNeutralHadrCands_;
      bool embeddedIsolationPFNeutralHadrCands_;
      mutable reco::PFCandidateRefVector isolationPFNeutralHadrCandsTransientRefVector_;
      mutable edm::BoolCache isolationPFNeutralHadrCandsRefVectorFixed_;
      std::vector<reco::PFCandidate> isolationPFGammaCands_;
      bool embeddedIsolationPFGammaCands_;
      mutable reco::PFCandidateRefVector isolationPFGammaCandsTransientRefVector_;
      mutable edm::BoolCache isolationPFGammaCandsRefVectorFixed_;

      // ---- matched GenJet holder ----
      std::vector<reco::GenJet> genJet_;
      // ---- tau ID's holder ----
      std::vector<IdPair> tauIDs_;
      // ---- CaloTau specific variables  ----
      std::vector<pat::tau::TauCaloSpecific> caloSpecific_;
      // ---- PFTau specific variables  ----
      std::vector<pat::tau::TauPFSpecific> pfSpecific_;
  };
}

#endif