Reference Manual

pat::tau::TauPFSpecific::caloComp_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

float pat::Tau::caloComp ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 254 of file Tau.h.

References pat::tau::TauPFSpecific::caloComp_, and pfSpecific().

254 { return pfSpecific().caloComp_; }

float caloComp_

Definition: TauPFSpecific.h:58

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

const pat::tau::TauCaloSpecific& pat::Tau::caloSpecific ( ) const

return CaloTau info or throw exception 'not CaloTau'

Referenced by caloTauTagInfoRef(), isolationECALhitsEtSum(), isolationTracksPtSum(), leadTrackHCAL3x3hitsEtSum(), leadTrackHCAL3x3hottesthitDEta(), leadTracksignedSipt(), maximumHCALhitEt(), signalTracksInvariantMass(), and TracksInvariantMass().

reco::CaloTauTagInfoRef pat::Tau::caloTauTagInfoRef ( ) const

inline

Method copied from reco::CaloTau. Throws an exception if this pat::Tau was not made from a reco::CaloTau

Definition at line 130 of file Tau.h.

References caloSpecific(), and pat::tau::TauCaloSpecific::CaloTauTagInfoRef_.

130 { return caloSpecific().CaloTauTagInfoRef_; }

pat::tau::TauCaloSpecific::CaloTauTagInfoRef_

const pat::tau::TauCaloSpecific & caloSpecific() const

return CaloTau info or throw exception 'not CaloTau'

reco::CaloTauTagInfoRef CaloTauTagInfoRef_

Definition: TauCaloSpecific.h:25

virtual Tau* pat::Tau::clone ( void ) const

inlinevirtual

required reimplementation of the Candidate's clone method

Reimplemented from pat::Lepton< reco::BaseTau >.

Definition at line 78 of file Tau.h.

References Tau().

78 { return new Tau(*this); }

pat::Tau::Tau

Tau()

default constructor

const LorentzVector& pat::Tau::correctedP4	(	const std::string &	level,
		const std::string &	set = `""`
	)		const

inline

p4 of the jet corrected up to the given level for the set of jet energy correction factors, which is currently in use

Definition at line 399 of file Tau.h.

References correctedTauJet(), and reco::LeafCandidate::p4().

                                                                                                 { 
     return correctedTauJet(level, set).p4(); 
       }

const LorentzVector& pat::Tau::correctedP4	(	const unsigned int &	level,
		const unsigned int &	set = `0`
	)		const

inline

p4 of the jet corrected up to the given level for the set of jet energy correction factors, which is currently in use

Definition at line 404 of file Tau.h.

References correctedTauJet(), and reco::LeafCandidate::p4().

                                                                                                      { 
     return correctedTauJet(level, set).p4(); 
       }

Tau pat::Tau::correctedTauJet	(	const std::string &	level,
		const std::string &	set = `""`
	)		const

copy of the jet corrected up to the given level for the set of jet energy correction factors, which is currently in use

Referenced by correctedP4().

Tau pat::Tau::correctedTauJet	(	const unsigned int &	level,
		const unsigned int &	set = `0`
	)		const

copy of the jet corrected up to the given level for the set of jet energy correction factors, which is currently in use

std::string pat::Tau::currentJECLevel ( ) const

inline

return the name of the current step of jet energy corrections

Definition at line 382 of file Tau.h.

References currentJECLevel_, currentJECSet_, jec_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                         { 
     return currentJECSet_<jec_.size() ? jec_.at(currentJECSet_).jecLevel(currentJECLevel_) : std::string("ERROR"); 
       }

void pat::Tau::currentJECLevel ( const unsigned int & level )

inlineprotected

update the current JEC level; used by correctedJet

Definition at line 419 of file Tau.h.

References currentJECLevel_, and testEve_cfg::level.

419 { currentJECLevel_=level; };

pat::Tau::currentJECLevel_

unsigned int currentJECLevel_

Definition: Tau.h:492

testEve_cfg.level

tuple level

Definition: testEve_cfg.py:34

std::string pat::Tau::currentJECSet ( ) const

inline

returns the label of the current set of jet energy corrections

Definition at line 378 of file Tau.h.

References currentJECSet_, jec_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                       { 
     return currentJECSet_<jec_.size() ? jec_.at(currentJECSet_).jecSet() : std::string("ERROR"); 
       }

void pat::Tau::currentJECSet ( const unsigned int & set )

inlineprotected

update the current JEC set; used by correctedJet

Definition at line 417 of file Tau.h.

References currentJECSet_.

417 { currentJECSet_=set; };

pat::Tau::currentJECSet_

unsigned int currentJECSet_

Definition: Tau.h:490

int pat::Tau::decayMode ( ) const

inline

reconstructed tau decay mode (specific to PFTau)

Definition at line 337 of file Tau.h.

References pat::tau::TauPFEssential::decayMode_, and pfEssential().

Referenced by Tau.Tau::__str__().

337 { return pfEssential().decayMode_; }

pat::tau::TauPFEssential::decayMode_

const pat::tau::TauPFEssential & pfEssential() const

int decayMode_

Definition: TauPFEssential.h:36

float pat::Tau::dxy ( ) const

inline

Definition at line 315 of file Tau.h.

References pat::tau::TauPFEssential::dxy_, and pfEssential().

315 { return pfEssential().dxy_; }

pat::tau::TauPFEssential::dxy_

float dxy_

Definition: TauPFEssential.h:39

pat::tau::TauPFEssential::dxy_error_

const pat::tau::TauPFEssential & pfEssential() const

float pat::Tau::dxy_error ( ) const

inline

Definition at line 316 of file Tau.h.

References pat::tau::TauPFEssential::dxy_error_, and pfEssential().

316 { return pfEssential().dxy_error_; }

float dxy_error_

Definition: TauPFEssential.h:40

pat::tau::TauPFEssential::dxy_PCA_

const pat::tau::TauPFEssential & pfEssential() const

const pat::tau::TauPFEssential::Point& pat::Tau::dxy_PCA ( ) const

inline

-— Tau lifetime information -— Filled from PFTauTIPAssociation. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 314 of file Tau.h.

References pat::tau::TauPFEssential::dxy_PCA_, and pfEssential().

314 { return pfEssential().dxy_PCA_; }

Point dxy_PCA_

Definition: TauPFEssential.h:38

pat::tau::TauPFSpecific::ecalStripSumEOverPLead_

const pat::tau::TauPFEssential & pfEssential() const

float pat::Tau::dxy_Sig ( ) const

float pat::Tau::ecalStripSumEOverPLead ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 239 of file Tau.h.

References pat::tau::TauPFSpecific::ecalStripSumEOverPLead_, and pfSpecific().

239 { return pfSpecific().ecalStripSumEOverPLead_; }

float ecalStripSumEOverPLead_

Definition: TauPFSpecific.h:52

pat::tau::TauPFSpecific::electronPreIDDecision_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

bool pat::Tau::electronPreIDDecision ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 251 of file Tau.h.

References pat::tau::TauPFSpecific::electronPreIDDecision_, and pfSpecific().

251 { return pfSpecific().electronPreIDDecision_; }

bool electronPreIDDecision_

Definition: TauPFSpecific.h:56

pat::tau::TauPFSpecific::electronPreIDOutput_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

float pat::Tau::electronPreIDOutput ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 248 of file Tau.h.

References pat::tau::TauPFSpecific::electronPreIDOutput_, and pfSpecific().

248 { return pfSpecific().electronPreIDOutput_; }

float electronPreIDOutput_

Definition: TauPFSpecific.h:55

pat::tau::TauPFSpecific::electronPreIDTrack_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

const reco::TrackRef& pat::Tau::electronPreIDTrack ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 245 of file Tau.h.

References pat::tau::TauPFSpecific::electronPreIDTrack_, and pfSpecific().

245 { return pfSpecific().electronPreIDTrack_; }

reco::TrackRef electronPreIDTrack_

Definition: TauPFSpecific.h:54

pat::tau::TauPFSpecific::emFraction_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

void pat::Tau::embedIsolationPFCands ( )

method to store the isolation candidates internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedIsolationPFChargedHadrCands ( )

method to store the isolation charged hadrons candidates internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedIsolationPFGammaCands ( )

method to store the isolation gamma candidates internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedIsolationPFNeutralHadrCands ( )

method to store the isolation neutral hadrons candidates internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedIsolationTracks ( )

method to store the isolation tracks internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedLeadPFCand ( )

PFTau specific content - method to store the leading candidate internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedLeadPFChargedHadrCand ( )

method to store the leading charged hadron candidate internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedLeadPFNeutralCand ( )

method to store the leading neutral candidate internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedLeadTrack ( )

method to store the leading track internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedSignalPFCands ( )

method to store the signal candidates internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedSignalPFChargedHadrCands ( )

method to store the signal charged hadrons candidates internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedSignalPFGammaCands ( )

method to store the signal gamma candidates internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedSignalPFNeutralHadrCands ( )

method to store the signal neutral hadrons candidates internally

Referenced by pat::PATTauProducer::produce().

void pat::Tau::embedSignalTracks ( )

method to store the signal tracks internally

Referenced by pat::PATTauProducer::produce().

float pat::Tau::emFraction ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 227 of file Tau.h.

References pat::tau::TauPFSpecific::emFraction_, and pfSpecific().

227 { return pfSpecific().emFraction_; }

float emFraction_

Definition: TauPFSpecific.h:48

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

float pat::Tau::etaetaMoment ( ) const

float pat::Tau::etaphiMoment ( ) const

bool pat::Tau::ExistIsolationCands ( ) const

bool pat::Tau::ExistSignalCands ( ) const

return the PFCandidates if available (reference or embedded), or the PackedPFCandidate on miniAOD note that the vector is returned by value.

const pat::tau::TauPFEssential::Vector& pat::Tau::flightLength ( ) const

inline

Definition at line 322 of file Tau.h.

References pat::tau::TauPFEssential::flightLength_, and pfEssential().

322 { return pfEssential().flightLength_; }

pat::tau::TauPFEssential::flightLength_

const pat::tau::TauPFEssential & pfEssential() const

Vector flightLength_

Definition: TauPFEssential.h:46

pat::tau::TauPFEssential::CovMatrix pat::Tau::flightLengthCov ( ) const

float pat::Tau::flightLengthSig ( ) const

inline

Definition at line 323 of file Tau.h.

References pat::tau::TauPFEssential::flightLengthSig_, and pfEssential().

323 { return pfEssential().flightLengthSig_; }

pat::tau::TauPFEssential::flightLengthSig_

const pat::tau::TauPFEssential & pfEssential() const

float flightLengthSig_

Definition: TauPFEssential.h:47

const reco::GenJet* pat::Tau::genJet ( ) const

return matched GenJet, built from the visible particles of a generated tau

bool pat::Tau::hasSecondaryVertex ( ) const

inline

Definition at line 321 of file Tau.h.

References pat::tau::TauPFEssential::hasSV_, and pfEssential().

321 { return pfEssential().hasSV_; }

pat::tau::TauPFEssential::hasSV_

bool hasSV_

Definition: TauPFEssential.h:45

pat::tau::TauPFSpecific::hcal3x3OverPLead_

const pat::tau::TauPFEssential & pfEssential() const

float pat::Tau::hcal3x3OverPLead ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 236 of file Tau.h.

References pat::tau::TauPFSpecific::hcal3x3OverPLead_, and pfSpecific().

236 { return pfSpecific().hcal3x3OverPLead_; }

float hcal3x3OverPLead_

Definition: TauPFSpecific.h:51

pat::tau::TauPFSpecific::hcalMaxOverPLead_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

float pat::Tau::hcalMaxOverPLead ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 233 of file Tau.h.

References pat::tau::TauPFSpecific::hcalMaxOverPLead_, and pfSpecific().

233 { return pfSpecific().hcalMaxOverPLead_; }

float hcalMaxOverPLead_

Definition: TauPFSpecific.h:50

pat::tau::TauPFSpecific::hcalTotOverPLead_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

float pat::Tau::hcalTotOverPLead ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 230 of file Tau.h.

References pat::tau::TauPFSpecific::hcalTotOverPLead_, and pfSpecific().

230 { return pfSpecific().hcalTotOverPLead_; }

float hcalTotOverPLead_

Definition: TauPFSpecific.h:49

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

void pat::Tau::initializeJEC	(	unsigned int	level,
		const unsigned int	set = `0`
	)

protected

initialize the jet to a given JEC level during creation starting from Uncorrected

Referenced by pat::PATTauProducer::produce().

bool pat::Tau::isCaloTau ( ) const

inline

Returns true if this pat::Tau was made from a reco::CaloTau.

Definition at line 125 of file Tau.h.

References caloSpecific_.

125 { return !caloSpecific_.empty(); }

pat::Tau::caloSpecific_

std::vector< pat::tau::TauCaloSpecific > caloSpecific_

holder for CaloTau info, or empty vector if PFTau

Definition: Tau.h:481

reco::CandidatePtrVector pat::Tau::isolationCands ( ) const

return the PFCandidates if available (reference or embedded), or the PackedPFCandidate on miniAOD note that the vector is returned by value.

reco::CandidatePtrVector pat::Tau::isolationChargedHadrCands ( ) const

return the PFCandidates if available (reference or embedded), or the PackedPFCandidate on miniAOD note that the vector is returned by value.

float pat::Tau::isolationECALhitsEtSum ( ) const

inline

Method copied from reco::CaloTau. Throws an exception if this pat::Tau was not made from a reco::CaloTau

Definition at line 151 of file Tau.h.

References caloSpecific(), and pat::tau::TauCaloSpecific::isolationECALhitsEtSum_.

151 { return caloSpecific().isolationECALhitsEtSum_; }

pat::tau::TauCaloSpecific::isolationECALhitsEtSum_

const pat::tau::TauCaloSpecific & caloSpecific() const

return CaloTau info or throw exception 'not CaloTau'

float isolationECALhitsEtSum_

Definition: TauCaloSpecific.h:32

reco::CandidatePtrVector pat::Tau::isolationGammaCands ( ) const

return the PFCandidates if available (reference or embedded), or the PackedPFCandidate on miniAOD note that the vector is returned by value.

reco::CandidatePtrVector pat::Tau::isolationNeutrHadrCands ( ) const

return the PFCandidates if available (reference or embedded), or the PackedPFCandidate on miniAOD note that the vector is returned by value.

const std::vector<reco::PFCandidatePtr>& pat::Tau::isolationPFCands ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

const std::vector<reco::PFCandidatePtr>& pat::Tau::isolationPFChargedHadrCands ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Referenced by pat::PATTauSlimmer::produce().

float pat::Tau::isolationPFChargedHadrCandsPtSum ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 218 of file Tau.h.

References pat::tau::TauPFSpecific::isolationPFChargedHadrCandsPtSum_, and pfSpecific().

218 { return pfSpecific().isolationPFChargedHadrCandsPtSum_; }

pat::tau::TauPFSpecific::isolationPFChargedHadrCandsPtSum_

float isolationPFChargedHadrCandsPtSum_

Definition: TauPFSpecific.h:44

pat::tau::TauPFSpecific::isolationPFGammaCandsEtSum_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

const std::vector<reco::PFCandidatePtr>& pat::Tau::isolationPFGammaCands ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Referenced by pat::PATTauSlimmer::produce().

float pat::Tau::isolationPFGammaCandsEtSum ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 221 of file Tau.h.

References pat::tau::TauPFSpecific::isolationPFGammaCandsEtSum_, and pfSpecific().

221 { return pfSpecific().isolationPFGammaCandsEtSum_; }

float isolationPFGammaCandsEtSum_

Definition: TauPFSpecific.h:45

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

const std::vector<reco::PFCandidatePtr>& pat::Tau::isolationPFNeutrHadrCands ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Referenced by pat::PATTauSlimmer::produce().

const std::vector<reco::RecoTauPiZero>& pat::Tau::isolationPiZeroCandidates ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

const std::vector<reco::PFRecoTauChargedHadron>& pat::Tau::isolationTauChargedHadronCandidates ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

const reco::TrackRefVector& pat::Tau::isolationTracks ( ) const

virtual

override the reco::BaseTau::isolationTracks method, to access the internal storage of the isolation tracks

Reimplemented from reco::BaseTau.

float pat::Tau::isolationTracksPtSum ( ) const

inline

Method copied from reco::CaloTau. Throws an exception if this pat::Tau was not made from a reco::CaloTau

Definition at line 148 of file Tau.h.

References caloSpecific(), and pat::tau::TauCaloSpecific::isolationTracksPtSum_.

148 { return caloSpecific().isolationTracksPtSum_; }

pat::tau::TauCaloSpecific::isolationTracksPtSum_

const pat::tau::TauCaloSpecific & caloSpecific() const

return CaloTau info or throw exception 'not CaloTau'

float isolationTracksPtSum_

Definition: TauCaloSpecific.h:31

bool pat::Tau::isPFTau ( ) const

inline

Returns true if this pat::Tau was made from a reco::PFTau.

Definition at line 158 of file Tau.h.

References pfSpecific_.

Referenced by pat::PATTauProducer::produce().

158 { return !pfSpecific_.empty(); }

pat::Tau::pfSpecific_

std::vector< pat::tau::TauPFSpecific > pfSpecific_

holder for PFTau info, or empty vector if CaloTau

Definition: Tau.h:477

bool pat::Tau::isTauIDAvailable ( const std::string & name ) const

Returns true if a specific ID is available in this pat::Tau.

float pat::Tau::jecFactor	(	const std::string &	level,
		const std::string &	set = `""`
	)		const

correction factor to the given level for a specific set of correction factors, starting from the current level

Referenced by Jet.Jet::rawFactor(), and Jet.Jet::setRawFactor().

float pat::Tau::jecFactor	(	const unsigned int &	level,
		const unsigned int &	set = `0`
	)		const

correction factor to the given level for a specific set of correction factors, starting from the current level

Referenced by Jet.Jet::rawFactor(), and Jet.Jet::setRawFactor().

int pat::Tau::jecSet ( const std::string & label ) const

protected

index of the set of jec factors with given label; returns -1 if no set of jec factors exists with the given label

Referenced by availableJECLevels(), and jecSetAvailable().

bool pat::Tau::jecSetAvailable ( const std::string & set ) const

inline

returns true if the jet carries a set of jet energy correction factors with the given label

Definition at line 373 of file Tau.h.

References jecSet().

373 {return (jecSet(set) >= 0); };

pat::Tau::jecSet

int jecSet(const std::string &label) const

bool pat::Tau::jecSetAvailable ( const unsigned int & set ) const

inline

returns true if the jet carries a set of jet energy correction factors with the given label

Definition at line 376 of file Tau.h.

References jec_.

376 {return (set < jec_.size()); };

pat::Tau::jec_

std::vector< pat::TauJetCorrFactors > jec_

Definition: Tau.h:487

bool pat::Tau::jecSetsAvailable ( ) const

inline

returns true if the jet carries jet energy correction information at all

Definition at line 370 of file Tau.h.

References jec_.

370 { return !jec_.empty(); }

pat::Tau::jec_

std::vector< pat::TauJetCorrFactors > jec_

Definition: Tau.h:487

const reco::CandidatePtr pat::Tau::leadCand ( ) const

return the PFCandidate if available (reference or embedded), or the PackedPFCandidate on miniAOD

const reco::CandidatePtr pat::Tau::leadChargedHadrCand ( ) const

--— Methods returning associated PFCandidates that work on PAT+AOD, PAT+embedding and miniAOD --— return the PFCandidate if available (reference or embedded), or the PackedPFCandidate on miniAOD

Referenced by Tau.Tau::dxy_approx(), and Tau.Tau::dz().

const reco::CandidatePtr pat::Tau::leadNeutralCand ( ) const

return the PFCandidate if available (reference or embedded), or the PackedPFCandidate on miniAOD

const reco::PFCandidatePtr pat::Tau::leadPFCand ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

const reco::PFCandidatePtr pat::Tau::leadPFChargedHadrCand ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

float pat::Tau::leadPFChargedHadrCandsignedSipt ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 173 of file Tau.h.

References pat::tau::TauPFSpecific::leadPFChargedHadrCandsignedSipt_, and pfSpecific().

173 { return pfSpecific().leadPFChargedHadrCandsignedSipt_; }

pat::tau::TauPFSpecific::leadPFChargedHadrCandsignedSipt_

float leadPFChargedHadrCandsignedSipt_

Definition: TauPFSpecific.h:29

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

const reco::PFCandidatePtr pat::Tau::leadPFNeutralCand ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

reco::PFRecoTauChargedHadronRef pat::Tau::leadTauChargedHadronCandidate ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

reco::TrackRef pat::Tau::leadTrack ( ) const

virtual

override the reco::BaseTau::leadTrack method, to access the internal storage of the leading track

Reimplemented from reco::BaseTau.

float pat::Tau::leadTrackHCAL3x3hitsEtSum ( ) const

inline

Method copied from reco::CaloTau. Throws an exception if this pat::Tau was not made from a reco::CaloTau

Definition at line 136 of file Tau.h.

References caloSpecific(), and pat::tau::TauCaloSpecific::leadTrackHCAL3x3hitsEtSum_.

136 { return caloSpecific().leadTrackHCAL3x3hitsEtSum_; }

pat::tau::TauCaloSpecific::leadTrackHCAL3x3hitsEtSum_

const pat::tau::TauCaloSpecific & caloSpecific() const

return CaloTau info or throw exception 'not CaloTau'

float leadTrackHCAL3x3hitsEtSum_

Definition: TauCaloSpecific.h:27

float pat::Tau::leadTrackHCAL3x3hottesthitDEta ( ) const

inline

Method copied from reco::CaloTau. Throws an exception if this pat::Tau was not made from a reco::CaloTau

Definition at line 139 of file Tau.h.

References caloSpecific(), and pat::tau::TauCaloSpecific::leadTrackHCAL3x3hottesthitDEta_.

139 { return caloSpecific().leadTrackHCAL3x3hottesthitDEta_; }

pat::tau::TauCaloSpecific::leadTrackHCAL3x3hottesthitDEta_

const pat::tau::TauCaloSpecific & caloSpecific() const

return CaloTau info or throw exception 'not CaloTau'

float leadTrackHCAL3x3hottesthitDEta_

Definition: TauCaloSpecific.h:28

float pat::Tau::leadTracksignedSipt ( ) const

inline

Method copied from reco::CaloTau. Throws an exception if this pat::Tau was not made from a reco::CaloTau

Definition at line 133 of file Tau.h.

References caloSpecific(), and pat::tau::TauCaloSpecific::leadTracksignedSipt_.

133 { return caloSpecific().leadTracksignedSipt_; }

pat::tau::TauCaloSpecific::leadTracksignedSipt_

float leadTracksignedSipt_

Definition: TauCaloSpecific.h:26

const pat::tau::TauCaloSpecific & caloSpecific() const

return CaloTau info or throw exception 'not CaloTau'

float pat::Tau::maximumHCALhitEt ( ) const

inline

Method copied from reco::CaloTau. Throws an exception if this pat::Tau was not made from a reco::CaloTau

Definition at line 154 of file Tau.h.

References caloSpecific(), and pat::tau::TauCaloSpecific::maximumHCALhitEt_.

154 { return caloSpecific().maximumHCALhitEt_; }

pat::tau::TauCaloSpecific::maximumHCALhitEt_

const pat::tau::TauCaloSpecific & caloSpecific() const

return CaloTau info or throw exception 'not CaloTau'

float maximumHCALhitEt_

Definition: TauCaloSpecific.h:33

float pat::Tau::maximumHCALPFClusterEt ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 224 of file Tau.h.

References pat::tau::TauPFSpecific::maximumHCALPFClusterEt_, and pfSpecific().

224 { return pfSpecific().maximumHCALPFClusterEt_; }

pat::tau::TauPFSpecific::maximumHCALPFClusterEt_

float maximumHCALPFClusterEt_

Definition: TauPFSpecific.h:46

pat::tau::TauPFSpecific::muonDecision_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

bool pat::Tau::muonDecision ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 260 of file Tau.h.

References pat::tau::TauPFSpecific::muonDecision_, and pfSpecific().

260 { return pfSpecific().muonDecision_; }

bool muonDecision_

Definition: TauPFSpecific.h:60

pat::tau::TauPFSpecific::pfJetRef_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

size_t pat::Tau::numberOfSourceCandidatePtrs ( ) const

virtual

--— Top Projection business ----— get the number of non-null PFCandidates

Reimplemented from reco::LeafCandidate.

reco::Candidate::LorentzVector pat::Tau::p4Jet ( ) const

Methods copied from reco::Jet. (accessible from reco::CaloTau/reco::PFTau via reco::CaloTauTagInfo/reco::PFTauTagInfo)

const pat::tau::TauPFEssential& pat::Tau::pfEssential ( ) const

Referenced by decayMode(), dxy(), dxy_error(), dxy_PCA(), flightLength(), flightLengthSig(), hasSecondaryVertex(), primaryVertex(), primaryVertexCov(), primaryVertexPos(), secondaryVertex(), secondaryVertexCov(), and secondaryVertexPos().

const reco::PFJetRef& pat::Tau::pfJetRef ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 164 of file Tau.h.

References pat::tau::TauPFSpecific::pfJetRef_, and pfSpecific().

Referenced by PFMEtSignInterfaceBase::compResolution().

164 { return pfSpecific().pfJetRef_; }

reco::PFJetRef pfJetRef_

Definition: TauPFSpecific.h:27

pat::tau::TauPFEssential::pv_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

const pat::tau::TauPFSpecific& pat::Tau::pfSpecific ( ) const

return PFTau info or throw exception 'not PFTau'

Referenced by bremsRecoveryEOverPLead(), caloComp(), ecalStripSumEOverPLead(), electronPreIDDecision(), electronPreIDOutput(), electronPreIDTrack(), emFraction(), hcal3x3OverPLead(), hcalMaxOverPLead(), hcalTotOverPLead(), isolationPFChargedHadrCandsPtSum(), isolationPFGammaCandsEtSum(), leadPFChargedHadrCandsignedSipt(), maximumHCALPFClusterEt(), muonDecision(), pfJetRef(), and segComp().

float pat::Tau::phiphiMoment ( ) const

const reco::VertexRef& pat::Tau::primaryVertex ( ) const

inline

Definition at line 318 of file Tau.h.

References pfEssential(), and pat::tau::TauPFEssential::pv_.

318 { return pfEssential().pv_; }

reco::VertexRef pv_

Definition: TauPFEssential.h:42

const pat::tau::TauPFEssential & pfEssential() const

const pat::tau::TauPFEssential::CovMatrix& pat::Tau::primaryVertexCov ( ) const

inline

Definition at line 320 of file Tau.h.

References pfEssential(), and pat::tau::TauPFEssential::pvCov_.

320 { return pfEssential().pvCov_; }

pat::tau::TauPFEssential::pvCov_

const pat::tau::TauPFEssential & pfEssential() const

CovMatrix pvCov_

Definition: TauPFEssential.h:44

const pat::tau::TauPFEssential::Point& pat::Tau::primaryVertexPos ( ) const

inline

Definition at line 319 of file Tau.h.

References pfEssential(), and pat::tau::TauPFEssential::pvPos_.

319 { return pfEssential().pvPos_; }

pat::tau::TauPFEssential::pvPos_

const pat::tau::TauPFEssential & pfEssential() const

Point pvPos_

Definition: TauPFEssential.h:43

const reco::VertexRef& pat::Tau::secondaryVertex ( ) const

inline

Definition at line 325 of file Tau.h.

References pfEssential(), and pat::tau::TauPFEssential::sv_.

325 { return pfEssential().sv_; }

pat::tau::TauPFEssential::sv_

reco::VertexRef sv_

Definition: TauPFEssential.h:48

const pat::tau::TauPFEssential & pfEssential() const

const pat::tau::TauPFEssential::CovMatrix& pat::Tau::secondaryVertexCov ( ) const

inline

Definition at line 327 of file Tau.h.

References pfEssential(), and pat::tau::TauPFEssential::svCov_.

327 { return pfEssential().svCov_; }

pat::tau::TauPFEssential::svCov_

const pat::tau::TauPFEssential & pfEssential() const

CovMatrix svCov_

Definition: TauPFEssential.h:50

const pat::tau::TauPFEssential::Point& pat::Tau::secondaryVertexPos ( ) const

inline

Definition at line 326 of file Tau.h.

References pfEssential(), and pat::tau::TauPFEssential::svPos_.

326 { return pfEssential().svPos_; }

pat::tau::TauPFEssential::svPos_

const pat::tau::TauPFEssential & pfEssential() const

Point svPos_

Definition: TauPFEssential.h:49

float pat::Tau::segComp ( ) const

inline

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Definition at line 257 of file Tau.h.

References pfSpecific(), and pat::tau::TauPFSpecific::segComp_.

257 { return pfSpecific().segComp_; }

pat::tau::TauPFSpecific::segComp_

float segComp_

Definition: TauPFSpecific.h:59

pat::Tau::isolationChargedHadrCandPtrs_

const pat::tau::TauPFSpecific & pfSpecific() const

return PFTau info or throw exception 'not PFTau'

void pat::Tau::setDecayMode ( int )

set decay mode

Referenced by pat::PATTauProducer::produce().

void pat::Tau::setGenJet ( const reco::GenJetRef & ref )

set the matched GenJet

Referenced by pat::PATTauProducer::produce().

void pat::Tau::setIsolationChargedHadrCands ( const reco::CandidatePtrVector & ptrs )

inline

Definition at line 300 of file Tau.h.

References isolationChargedHadrCandPtrs_.

Referenced by pat::PATTauSlimmer::produce().

300 { isolationChargedHadrCandPtrs_ = ptrs;}

reco::CandidatePtrVector isolationChargedHadrCandPtrs_

Definition: Tau.h:499

void pat::Tau::setIsolationGammaCands ( const reco::CandidatePtrVector & ptrs )

inline

Definition at line 302 of file Tau.h.

References isolationGammaCandPtrs_.

Referenced by pat::PATTauSlimmer::produce().

302 { isolationGammaCandPtrs_ = ptrs;}

pat::Tau::isolationGammaCandPtrs_

reco::CandidatePtrVector isolationGammaCandPtrs_

Definition: Tau.h:501

void pat::Tau::setIsolationNeutralHadrCands ( const reco::CandidatePtrVector & ptrs )

inline

Definition at line 301 of file Tau.h.

References isolationNeutralHadrCandPtrs_.

Referenced by pat::PATTauSlimmer::produce().

301 { isolationNeutralHadrCandPtrs_ = ptrs;}

pat::Tau::isolationNeutralHadrCandPtrs_

reco::CandidatePtrVector isolationNeutralHadrCandPtrs_

Definition: Tau.h:500

void pat::Tau::setSignalChargedHadrCands ( const reco::CandidatePtrVector & ptrs )

inline

setters for the PtrVectors (for miniAOD)

Definition at line 297 of file Tau.h.

References signalChargedHadrCandPtrs_.

Referenced by pat::PATTauSlimmer::produce().

297 { signalChargedHadrCandPtrs_ = ptrs;}

pat::Tau::signalChargedHadrCandPtrs_

reco::CandidatePtrVector signalChargedHadrCandPtrs_

Definition: Tau.h:495

void pat::Tau::setSignalGammaCands ( const reco::CandidatePtrVector & ptrs )

inline

Definition at line 299 of file Tau.h.

References signalGammaCandPtrs_.

Referenced by pat::PATTauSlimmer::produce().

299 { signalGammaCandPtrs_ = ptrs;}

pat::Tau::signalGammaCandPtrs_

reco::CandidatePtrVector signalGammaCandPtrs_

Definition: Tau.h:497

void pat::Tau::setSignalNeutralHadrCands ( const reco::CandidatePtrVector & ptrs )

inline

Definition at line 298 of file Tau.h.

References signalNeutralHadrCandPtrs_.

Referenced by pat::PATTauSlimmer::produce().

298 { signalNeutralHadrCandPtrs_ = ptrs;}

pat::Tau::signalNeutralHadrCandPtrs_

reco::CandidatePtrVector signalNeutralHadrCandPtrs_

Definition: Tau.h:496

void pat::Tau::setTauIDs ( const std::vector< IdPair > & ids )

inline

Store multiple tau ID values, discarding existing ones The first one in the list becomes the 'default' tau id

Definition at line 356 of file Tau.h.

References tauIDs_.

Referenced by pat::PATTauProducer::produce().

356 { tauIDs_ = ids; }

pat::Tau::tauIDs_

std::vector< IdPair > tauIDs_

Definition: Tau.h:473

reco::CandidatePtrVector pat::Tau::signalCands ( ) const

Referenced by reco::PFMETProducerMVA::chargedEnFrac().

reco::CandidatePtrVector pat::Tau::signalChargedHadrCands ( ) const

return the PFCandidates if available (reference or embedded), or the PackedPFCandidate on miniAOD note that the vector is returned by value.

reco::CandidatePtrVector pat::Tau::signalGammaCands ( ) const

return the PFCandidates if available (reference or embedded), or the PackedPFCandidate on miniAOD note that the vector is returned by value.

reco::CandidatePtrVector pat::Tau::signalNeutrHadrCands ( ) const

return the PFCandidates if available (reference or embedded), or the PackedPFCandidate on miniAOD note that the vector is returned by value.

const std::vector<reco::PFCandidatePtr>& pat::Tau::signalPFCands ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

const std::vector<reco::PFCandidatePtr>& pat::Tau::signalPFChargedHadrCands ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Referenced by pat::PATTauSlimmer::produce().

const std::vector<reco::PFCandidatePtr>& pat::Tau::signalPFGammaCands ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Referenced by pat::PATTauSlimmer::produce().

const std::vector<reco::PFCandidatePtr>& pat::Tau::signalPFNeutrHadrCands ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

Referenced by pat::PATTauSlimmer::produce().

const std::vector<reco::RecoTauPiZero>& pat::Tau::signalPiZeroCandidates ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

const std::vector<reco::PFRecoTauChargedHadron>& pat::Tau::signalTauChargedHadronCandidates ( ) const

Method copied from reco::PFTau. Throws an exception if this pat::Tau was not made from a reco::PFTau

const reco::TrackRefVector& pat::Tau::signalTracks ( ) const

virtual

override the reco::BaseTau::signalTracks method, to access the internal storage of the signal tracks

Reimplemented from reco::BaseTau.

float pat::Tau::signalTracksInvariantMass ( ) const

inline

Method copied from reco::CaloTau. Throws an exception if this pat::Tau was not made from a reco::CaloTau

Definition at line 142 of file Tau.h.

References caloSpecific(), and pat::tau::TauCaloSpecific::signalTracksInvariantMass_.

142 { return caloSpecific().signalTracksInvariantMass_; }

pat::tau::TauCaloSpecific::signalTracksInvariantMass_

const pat::tau::TauCaloSpecific & caloSpecific() const

return CaloTau info or throw exception 'not CaloTau'

float signalTracksInvariantMass_

Definition: TauCaloSpecific.h:29

reco::CandidatePtr pat::Tau::sourceCandidatePtr ( size_type i ) const

virtual

get the source candidate pointer with index i

Reimplemented from reco::LeafCandidate.

float pat::Tau::tauID ( const std::string & name ) const

Returns a specific tau ID associated to the pat::Tau given its name For cut-based IDs, the value is 1.0 for good, 0.0 for bad. The names are defined within the configuration parameterset "tauIDSources" in PhysicsTools/PatAlgos/python/producersLayer1/tauProducer_cfi.py . Note: an exception is thrown if the specified ID is not available

float pat::Tau::tauID ( const char * name ) const

inline

Definition at line 348 of file Tau.h.

References AlCaHLTBitMon_QueryRunRegistry::string, and tauID().

Referenced by tauID().

348 {return tauID( std::string(name) );}

pat::Tau::tauID

float tauID(const std::string &name) const

mergeVDriftHistosByStation.name

string name

Definition: mergeVDriftHistosByStation.py:77

AlCaHLTBitMon_QueryRunRegistry.string

string string

Definition: AlCaHLTBitMon_QueryRunRegistry.py:255

const std::vector<IdPair>& pat::Tau::tauIDs ( ) const

inline

Returns all the tau IDs in the form of <name,value> pairs The 'default' ID is the first in the list

Definition at line 353 of file Tau.h.

References tauIDs_.

353 { return tauIDs_; }

pat::Tau::tauIDs_

std::vector< IdPair > tauIDs_

Definition: Tau.h:473

float pat::Tau::TracksInvariantMass ( ) const

inline

Method copied from reco::CaloTau. Throws an exception if this pat::Tau was not made from a reco::CaloTau

Definition at line 145 of file Tau.h.

References caloSpecific(), and pat::tau::TauCaloSpecific::TracksInvariantMass_.

145 { return caloSpecific().TracksInvariantMass_; }