Reference Manual

pat::tau::TauPFSpecific::bremsRecoveryEOverPLead_

void set(const std::string &name, int value)

set the flag, with a run-time name

Definition: ProfilingTools.cc:67

const std::vector< std::string > Tau::availableJECSets ( ) const

all available label-names of all sets of jet energy corrections

-— methods for jet corrections -— returns the labels of all available sets of jet energy corrections

Definition at line 610 of file Tau.cc.

References jec_.

 {
   std::vector<std::string> sets;
   for ( std::vector<pat::TauJetCorrFactors>::const_iterator corrFactor = jec_.begin(); 
     corrFactor != jec_.end(); ++corrFactor ) {
     sets.push_back(corrFactor->jecSet());
   }
   return sets;
 }

float pat::Tau::bremsRecoveryEOverPLead ( ) const

inline

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

Definition at line 226 of file Tau.h.

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

226 { return pfSpecific().bremsRecoveryEOverPLead_; }

float bremsRecoveryEOverPLead_

Definition: TauPFSpecific.h:51

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

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 238 of file Tau.h.

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

238 { return pfSpecific().caloComp_; }

pat::tau::TauPFSpecific::caloComp_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

float caloComp_

Definition: TauPFSpecific.h:56

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

return CaloTau info or throw exception 'not CaloTau'

Definition at line 283 of file Tau.cc.

References caloSpecific_, edm::hlt::Exception, and isCaloTau().

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

                                                       {
   if (!isCaloTau()) throw cms::Exception("Type Error") << "Requesting a CaloTau-specific information from a pat::Tau which wasn't made from a CaloTau.\n";
   return caloSpecific_[0]; 
 }

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 124 of file Tau.h.

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

124 { return caloSpecific().CaloTauTagInfoRef_; }

pat::tau::TauCaloSpecific::CaloTauTagInfoRef_

reco::CaloTauTagInfoRef CaloTauTagInfoRef_

Definition: TauCaloSpecific.h:27

pat::Tau::currentJECLevel_

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

return CaloTau info or throw exception 'not CaloTau'

Definition: Tau.cc:283

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 72 of file Tau.h.

References Tau().

72 { return new Tau(*this); }

pat::Tau::Tau

Tau()

default constructor

Definition: Tau.cc:13

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 316 of file Tau.h.

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

                                                                                                 { 
     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 321 of file Tau.h.

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

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

Tau 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

copy of the jet with correction factor to target step for the set of correction factors, which is currently in use

Definition at line 659 of file Tau.cc.

References edm::hlt::Exception, jec_, and runtimedef::set().

Referenced by correctedP4(), and correctedTauJet().

 {
   // rescale p4 of the jet; the update of current values is
   // done within the called jecFactor function
   for ( unsigned int idx = 0; idx < jec_.size(); ++idx ) {
     if ( set.empty() || jec_.at(idx).jecSet() == set ) {
       if ( jec_[idx].jecLevel(level) >= 0 ) 
     return correctedTauJet(jec_[idx].jecLevel(level), idx);
       else
     throw cms::Exception("InvalidRequest") 
       << "This JEC level " << level << " does not exist. \n";
     }
   }
   throw cms::Exception("InvalidRequest") 
     << "This JEC set " << set << " does not exist. \n";
 }

Tau 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

copy of the jet with correction factor to target step for the set of correction factors, which is currently in use

Definition at line 678 of file Tau.cc.

References correctedTauJet(), currentJECLevel(), currentJECSet(), jecFactor(), reco::LeafCandidate::p4(), and reco::LeafCandidate::setP4().

 {
   Tau correctedTauJet(*this);
   //rescale p4 of the jet
   correctedTauJet.setP4(jecFactor(level, set)*p4());
   // update current level and set
   correctedTauJet.currentJECSet(set); 
   correctedTauJet.currentJECLevel(level); 
   return correctedTauJet;
 }

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

inline

return the name of the current step of jet energy corrections

Definition at line 299 of file Tau.h.

References currentJECLevel_, currentJECSet_, and jec_.

Referenced by correctedTauJet(), and initializeJEC().

                                         { 
     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 333 of file Tau.h.

References currentJECLevel_, and testEve_cfg::level.

333 { currentJECLevel_=level; };

unsigned int currentJECLevel_

Definition: Tau.h:414

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 295 of file Tau.h.

References currentJECSet_, and jec_.

Referenced by correctedTauJet(), and initializeJEC().

                                       { 
     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 331 of file Tau.h.

References currentJECSet_, and runtimedef::set().

331 { currentJECSet_=set; };

pat::Tau::currentJECSet_

unsigned int currentJECSet_

Definition: Tau.h:412

pat::tau::TauPFSpecific::decayMode_

void set(const std::string &name, int value)

set the flag, with a run-time name

Definition: ProfilingTools.cc:67

int pat::Tau::decayMode ( ) const

inline

reconstructed tau decay mode (specific to PFTau)

Definition at line 254 of file Tau.h.

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

Referenced by setDecayMode().

254 { return pfSpecific().decayMode_; }

int decayMode_

Definition: TauPFSpecific.h:65

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

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 223 of file Tau.h.

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

223 { return pfSpecific().ecalStripSumEOverPLead_; }

pat::tau::TauPFSpecific::ecalStripSumEOverPLead_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

float ecalStripSumEOverPLead_

Definition: TauPFSpecific.h:50

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 235 of file Tau.h.

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

235 { return pfSpecific().electronPreIDDecision_; }

pat::tau::TauPFSpecific::electronPreIDDecision_

bool electronPreIDDecision_

Definition: TauPFSpecific.h:54

pat::tau::TauPFSpecific::electronPreIDOutput_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

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 232 of file Tau.h.

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

232 { return pfSpecific().electronPreIDOutput_; }

float electronPreIDOutput_

Definition: TauPFSpecific.h:53

pat::tau::TauPFSpecific::electronPreIDTrack_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

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 229 of file Tau.h.

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

229 { return pfSpecific().electronPreIDTrack_; }

reco::TrackRef electronPreIDTrack_

Definition: TauPFSpecific.h:52

pat::tau::TauPFSpecific::emFraction_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

void Tau::embedIsolationPFCands ( )

method to store the isolation candidates internally

Definition at line 397 of file Tau.cc.

References edm::RefVector< C, T, F >::at(), embeddedIsolationPFCands_, i, isolationPFCands_, isPFTau(), pfSpecific_, and edm::RefVector< C, T, F >::size().

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

                                 {
   if (!isPFTau() ) {//additional check with warning in pat::tau producer
     return;
   }
   reco::PFCandidateRefVector candRefVec = pfSpecific_[0].selectedIsolationPFCands_;
   for (unsigned int i = 0; i < candRefVec.size(); i++) {
     isolationPFCands_.push_back(*candRefVec.at(i));
   }
   embeddedIsolationPFCands_ = true;
 }

void Tau::embedIsolationPFChargedHadrCands ( )

method to store the isolation charged hadrons candidates internally

Definition at line 408 of file Tau.cc.

References edm::RefVector< C, T, F >::at(), embeddedIsolationPFChargedHadrCands_, i, isolationPFChargedHadrCands_, isPFTau(), pfSpecific_, and edm::RefVector< C, T, F >::size().

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

                                            {
   if (!isPFTau() ) {//additional check with warning in pat::tau producer
     return;
   }
   reco::PFCandidateRefVector candRefVec = pfSpecific_[0].selectedIsolationPFChargedHadrCands_;
   for (unsigned int i = 0; i < candRefVec.size(); i++) {
     isolationPFChargedHadrCands_.push_back(*candRefVec.at(i));
   }
   embeddedIsolationPFChargedHadrCands_ = true;
 }

void Tau::embedIsolationPFGammaCands ( )

method to store the isolation gamma candidates internally

Definition at line 428 of file Tau.cc.

References edm::RefVector< C, T, F >::at(), embeddedIsolationPFGammaCands_, i, isolationPFGammaCands_, isPFTau(), pfSpecific_, and edm::RefVector< C, T, F >::size().

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

                                      {
   if (!isPFTau() ) {//additional check with warning in pat::tau producer
     return;
   }
   reco::PFCandidateRefVector candRefVec = pfSpecific_[0].selectedIsolationPFGammaCands_;
   for (unsigned int i = 0; i < candRefVec.size(); i++) {
     isolationPFGammaCands_.push_back(*candRefVec.at(i));
   }
   embeddedIsolationPFGammaCands_ = true;
 }

void Tau::embedIsolationPFNeutralHadrCands ( )

method to store the isolation neutral hadrons candidates internally

Definition at line 418 of file Tau.cc.

References edm::RefVector< C, T, F >::at(), embeddedIsolationPFNeutralHadrCands_, i, isolationPFNeutralHadrCands_, isPFTau(), pfSpecific_, and edm::RefVector< C, T, F >::size().

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

                                            {
   if (!isPFTau() ) {//additional check with warning in pat::tau producer
     return;
   }
   reco::PFCandidateRefVector candRefVec = pfSpecific_[0].selectedIsolationPFNeutrHadrCands_;
   for (unsigned int i = 0; i < candRefVec.size(); i++) {
     isolationPFNeutralHadrCands_.push_back(*candRefVec.at(i));
   }
   embeddedIsolationPFNeutralHadrCands_ = true;
 }

void Tau::embedIsolationTracks ( )

method to store the isolation tracks internally

Definition at line 212 of file Tau.cc.

References edm::RefVector< C, T, F >::at(), embeddedIsolationTracks_, i, reco::BaseTau::isolationTracks(), isolationTracks_, and edm::RefVector< C, T, F >::size().

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

                                {
   isolationTracks_.clear();
   reco::TrackRefVector trackRefVec = reco::BaseTau::isolationTracks();
   for (unsigned int i = 0; i < trackRefVec.size(); i++) {
     isolationTracks_.push_back(*trackRefVec.at(i));
   }
   embeddedIsolationTracks_ = true;
 }

void Tau::embedLeadPFCand ( )

method to store the leading candidate internally

PFTau specific content - method to store the leading candidate internally

Definition at line 323 of file Tau.cc.

References embeddedLeadPFCand_, isPFTau(), leadPFCand_, and pfSpecific_.

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

                           {
   if (!isPFTau() ) {//additional check with warning in pat::tau producer
     return;
   }
   leadPFCand_.clear();
   if (pfSpecific_[0].leadPFCand_.isNonnull() ) {
     leadPFCand_.push_back(*pfSpecific_[0].leadPFCand_); //already set in C-tor
     embeddedLeadPFCand_ = true;
   }
 }

void Tau::embedLeadPFChargedHadrCand ( )

method to store the leading charged hadron candidate internally

method to store the leading candidate internally

Definition at line 334 of file Tau.cc.

References embeddedLeadPFChargedHadrCand_, isPFTau(), leadPFChargedHadrCand_, and pfSpecific_.

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

                                      {
   if (!isPFTau() ) {//additional check with warning in pat::tau producer
     return;
   }
   leadPFChargedHadrCand_.clear();
   if (pfSpecific_[0].leadPFChargedHadrCand_.isNonnull() ) {
     leadPFChargedHadrCand_.push_back(*pfSpecific_[0].leadPFChargedHadrCand_); //already set in C-tor
     embeddedLeadPFChargedHadrCand_ = true;
   }
 }

void Tau::embedLeadPFNeutralCand ( )

method to store the leading neutral candidate internally

method to store the leading candidate internally

Definition at line 345 of file Tau.cc.

References embeddedLeadPFNeutralCand_, isPFTau(), leadPFNeutralCand_, and pfSpecific_.

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

                                  {
   if (!isPFTau() ) {//additional check with warning in pat::tau producer
     return;
   }
   leadPFNeutralCand_.clear();
   if (pfSpecific_[0].leadPFNeutralCand_.isNonnull() ) {
     leadPFNeutralCand_.push_back(*pfSpecific_[0].leadPFNeutralCand_); //already set in C-tor
     embeddedLeadPFNeutralCand_ = true;
   }
 }

void Tau::embedLeadTrack ( )

method to store the leading track internally

method to store the isolation tracks internally

Definition at line 223 of file Tau.cc.

References embeddedLeadTrack_, reco::BaseTau::leadTrack(), and leadTrack_.

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

                          {
   leadTrack_.clear();
   if (reco::BaseTau::leadTrack().isNonnull()) {
       leadTrack_.push_back(*reco::BaseTau::leadTrack());
       embeddedLeadTrack_ = true;
   }
 }

void Tau::embedSignalPFCands ( )

method to store the signal candidates internally

Definition at line 356 of file Tau.cc.

References edm::RefVector< C, T, F >::at(), embeddedSignalPFCands_, i, isPFTau(), pfSpecific_, signalPFCands_, and edm::RefVector< C, T, F >::size().

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

                              {
   if (!isPFTau() ) {//additional check with warning in pat::tau producer
     return;
   }
   reco::PFCandidateRefVector candRefVec = pfSpecific_[0].selectedSignalPFCands_;
   for (unsigned int i = 0; i < candRefVec.size(); i++) {
     signalPFCands_.push_back(*candRefVec.at(i));
   }
   embeddedSignalPFCands_ = true;
 }

void Tau::embedSignalPFChargedHadrCands ( )

method to store the signal charged hadrons candidates internally

Definition at line 366 of file Tau.cc.

References edm::RefVector< C, T, F >::at(), embeddedSignalPFChargedHadrCands_, i, isPFTau(), pfSpecific_, signalPFChargedHadrCands_, and edm::RefVector< C, T, F >::size().

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

                                         {
   if (!isPFTau() ) {//additional check with warning in pat::tau producer
     return;
   }
   reco::PFCandidateRefVector candRefVec = pfSpecific_[0].selectedSignalPFChargedHadrCands_;
   for (unsigned int i = 0; i < candRefVec.size(); i++) {
     signalPFChargedHadrCands_.push_back(*candRefVec.at(i));
   }
   embeddedSignalPFChargedHadrCands_ = true;
 }

void Tau::embedSignalPFGammaCands ( )

method to store the signal gamma candidates internally

Definition at line 386 of file Tau.cc.

References edm::RefVector< C, T, F >::at(), embeddedSignalPFGammaCands_, i, isPFTau(), pfSpecific_, signalPFGammaCands_, and edm::RefVector< C, T, F >::size().

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

                                   {
   if (!isPFTau() ) {//additional check with warning in pat::tau producer
     return;
   }
   reco::PFCandidateRefVector candRefVec = pfSpecific_[0].selectedSignalPFGammaCands_;
   for (unsigned int i = 0; i < candRefVec.size(); i++) {
     signalPFGammaCands_.push_back(*candRefVec.at(i));
   }
   embeddedSignalPFGammaCands_ = true;
 }

void Tau::embedSignalPFNeutralHadrCands ( )

method to store the signal neutral hadrons candidates internally

Definition at line 376 of file Tau.cc.

References edm::RefVector< C, T, F >::at(), embeddedSignalPFNeutralHadrCands_, i, isPFTau(), pfSpecific_, signalPFNeutralHadrCands_, and edm::RefVector< C, T, F >::size().

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

                                         {
   if (!isPFTau() ) {//additional check with warning in pat::tau producer
     return;
   }
   reco::PFCandidateRefVector candRefVec = pfSpecific_[0].selectedSignalPFNeutrHadrCands_;
   for (unsigned int i = 0; i < candRefVec.size(); i++) {
     signalPFNeutralHadrCands_.push_back(*candRefVec.at(i));
   }
   embeddedSignalPFNeutralHadrCands_ = true;
 }

void Tau::embedSignalTracks ( )

method to store the signal tracks internally

method to store the isolation tracks internally

Definition at line 233 of file Tau.cc.

References edm::RefVector< C, T, F >::at(), embeddedSignalTracks_, i, reco::BaseTau::signalTracks(), signalTracks_, and edm::RefVector< C, T, F >::size().

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

                            {
   signalTracks_.clear();
   reco::TrackRefVector trackRefVec = reco::BaseTau::signalTracks();
   for (unsigned int i = 0; i < trackRefVec.size(); i++) {
     signalTracks_.push_back(*trackRefVec.at(i));
   }
   embeddedSignalTracks_ = true;
 }

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 211 of file Tau.h.

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

211 { return pfSpecific().emFraction_; }

float emFraction_

Definition: TauPFSpecific.h:46

pat::tau::TauPFSpecific::hcal3x3OverPLead_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

float Tau::etaetaMoment ( ) const

Definition at line 295 of file Tau.cc.

References caloSpecific(), pat::tau::TauCaloSpecific::etaetaMoment_, pat::tau::TauPFSpecific::etaetaMoment_, edm::hlt::Exception, isCaloTau(), isPFTau(), and pfSpecific().

 {
   if ( isCaloTau() ) return caloSpecific().etaetaMoment_;
   if ( isPFTau()   ) return pfSpecific().etaetaMoment_;
   throw cms::Exception("Type Error") << "Requesting a CaloTau/PFTau-specific information from a pat::Tau which wasn't made from either a CaloTau or a PFTau.\n";
 }

float Tau::etaphiMoment ( ) const

Definition at line 309 of file Tau.cc.

References caloSpecific(), pat::tau::TauCaloSpecific::etaphiMoment_, pat::tau::TauPFSpecific::etaphiMoment_, edm::hlt::Exception, isCaloTau(), isPFTau(), and pfSpecific().

 {
   if ( isCaloTau() ) return caloSpecific().etaphiMoment_;
   if ( isPFTau()   ) return pfSpecific().etaphiMoment_;
   throw cms::Exception("Type Error") << "Requesting a CaloTau/PFTau-specific information from a pat::Tau which wasn't made from either a CaloTau or a PFTau.\n";
 }

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

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

return the matched generated jet

Definition at line 250 of file Tau.cc.

References genJet_.

                                      {
   return (genJet_.size() > 0 ? &genJet_.front() : 0);
 }

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 220 of file Tau.h.

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

220 { return pfSpecific().hcal3x3OverPLead_; }

float hcal3x3OverPLead_

Definition: TauPFSpecific.h:49

pat::tau::TauPFSpecific::hcalMaxOverPLead_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

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 217 of file Tau.h.

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

217 { return pfSpecific().hcalMaxOverPLead_; }

float hcalMaxOverPLead_

Definition: TauPFSpecific.h:48

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

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 214 of file Tau.h.

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

214 { return pfSpecific().hcalTotOverPLead_; }

pat::tau::TauPFSpecific::hcalTotOverPLead_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

float hcalTotOverPLead_

Definition: TauPFSpecific.h:47

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

protected

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

============= -Tau-jet Energy Correction methods ============ (copied from DataFormats/PatCandidates/src/Jet.cc)

Definition at line 592 of file Tau.cc.

References currentJECLevel(), currentJECSet(), jec_, reco::LeafCandidate::p4(), and reco::LeafCandidate::setP4().

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

 {
   currentJECSet(set);
   currentJECLevel(level);
   setP4(jec_[set].correction(level)*p4());
 }

bool pat::Tau::isCaloTau ( ) const

inline

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

Definition at line 119 of file Tau.h.

References caloSpecific_.

Referenced by caloSpecific(), etaetaMoment(), etaphiMoment(), p4Jet(), and phiphiMoment().

119 { return !caloSpecific_.empty(); }

pat::Tau::caloSpecific_

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

holder for CaloTau info, or empty vector if PFTau

Definition: Tau.h:399

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 145 of file Tau.h.

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

145 { return caloSpecific().isolationECALhitsEtSum_; }

pat::tau::TauCaloSpecific::isolationECALhitsEtSum_

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

return CaloTau info or throw exception 'not CaloTau'

Definition: Tau.cc:283

float isolationECALhitsEtSum_

Definition: TauCaloSpecific.h:34

const reco::PFCandidateRefVector & Tau::isolationPFCands ( ) const

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

Definition at line 524 of file Tau.cc.

References embeddedIsolationPFCands_, i, isolationPFCands_, isolationPFCandsRefVectorFixed_, isolationPFCandsTransientRefVector_, pfSpecific(), edm::RefVector< C, T, F >::push_back(), pat::tau::TauPFSpecific::selectedIsolationPFCands_, and edm::RefVector< C, T, F >::swap().

                                                              {
   if (embeddedIsolationPFCands_) {
     if (!isolationPFCandsRefVectorFixed_) {
       reco::PFCandidateRefVector aRefVec;
       for (unsigned int i = 0; i < isolationPFCands_.size(); i++) {
     aRefVec.push_back(reco::PFCandidateRef(&isolationPFCands_, i) );
       }
       isolationPFCandsTransientRefVector_.swap(aRefVec);
       isolationPFCandsRefVectorFixed_ = true;
     }
     return isolationPFCandsTransientRefVector_;
   } else
     return pfSpecific().selectedIsolationPFCands_;
 } 

const reco::PFCandidateRefVector & Tau::isolationPFChargedHadrCands ( ) const

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

Definition at line 539 of file Tau.cc.

References embeddedIsolationPFChargedHadrCands_, i, isolationPFChargedHadrCands_, isolationPFChargedHadrCandsRefVectorFixed_, isolationPFChargedHadrCandsTransientRefVector_, pfSpecific(), edm::RefVector< C, T, F >::push_back(), pat::tau::TauPFSpecific::selectedIsolationPFChargedHadrCands_, and edm::RefVector< C, T, F >::swap().

                                                                         {
   if (embeddedIsolationPFChargedHadrCands_) {
     if (!isolationPFChargedHadrCandsRefVectorFixed_) {
       reco::PFCandidateRefVector aRefVec;
       for (unsigned int i = 0; i < isolationPFChargedHadrCands_.size(); i++) {
     aRefVec.push_back(reco::PFCandidateRef(&isolationPFChargedHadrCands_, i) );
       }
       isolationPFChargedHadrCandsTransientRefVector_.swap(aRefVec);
       isolationPFChargedHadrCandsRefVectorFixed_ = true;
     }
     return isolationPFChargedHadrCandsTransientRefVector_;
   } else
     return pfSpecific().selectedIsolationPFChargedHadrCands_;
 } 

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 202 of file Tau.h.

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

202 { return pfSpecific().isolationPFChargedHadrCandsPtSum_; }

pat::tau::TauPFSpecific::isolationPFChargedHadrCandsPtSum_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

float isolationPFChargedHadrCandsPtSum_

Definition: TauPFSpecific.h:42

const reco::PFCandidateRefVector & Tau::isolationPFGammaCands ( ) const

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

Definition at line 569 of file Tau.cc.

References embeddedIsolationPFGammaCands_, i, isolationPFGammaCands_, isolationPFGammaCandsRefVectorFixed_, isolationPFGammaCandsTransientRefVector_, pfSpecific(), edm::RefVector< C, T, F >::push_back(), pat::tau::TauPFSpecific::selectedIsolationPFGammaCands_, and edm::RefVector< C, T, F >::swap().

                                                                   {
   if (embeddedIsolationPFGammaCands_) {
     if (!isolationPFGammaCandsRefVectorFixed_) {
       reco::PFCandidateRefVector aRefVec;
       for (unsigned int i = 0; i < isolationPFGammaCands_.size(); i++) {
     aRefVec.push_back(reco::PFCandidateRef(&isolationPFGammaCands_, i) );
       }
       isolationPFGammaCandsTransientRefVector_.swap(aRefVec);
       isolationPFGammaCandsRefVectorFixed_ = true;
     }
     return isolationPFGammaCandsTransientRefVector_;
   } else
     return pfSpecific().selectedIsolationPFGammaCands_;
 }

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 205 of file Tau.h.

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

205 { return pfSpecific().isolationPFGammaCandsEtSum_; }

pat::tau::TauPFSpecific::isolationPFGammaCandsEtSum_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

float isolationPFGammaCandsEtSum_

Definition: TauPFSpecific.h:43

const reco::PFCandidateRefVector & Tau::isolationPFNeutrHadrCands ( ) const

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

Definition at line 554 of file Tau.cc.

References embeddedIsolationPFNeutralHadrCands_, i, isolationPFNeutralHadrCands_, isolationPFNeutralHadrCandsRefVectorFixed_, isolationPFNeutralHadrCandsTransientRefVector_, pfSpecific(), edm::RefVector< C, T, F >::push_back(), pat::tau::TauPFSpecific::selectedIsolationPFNeutrHadrCands_, and edm::RefVector< C, T, F >::swap().

                                                                       {
   if (embeddedIsolationPFNeutralHadrCands_) {
     if (!isolationPFNeutralHadrCandsRefVectorFixed_) {
       reco::PFCandidateRefVector aRefVec;
       for (unsigned int i = 0; i < isolationPFNeutralHadrCands_.size(); i++) {
     aRefVec.push_back(reco::PFCandidateRef(&isolationPFNeutralHadrCands_, i) );
       }
       isolationPFNeutralHadrCandsTransientRefVector_.swap(aRefVec);
       isolationPFNeutralHadrCandsRefVectorFixed_ = true;
     }
     return isolationPFNeutralHadrCandsTransientRefVector_;
   } else
     return pfSpecific().selectedIsolationPFNeutrHadrCands_;
 } 

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

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

Definition at line 584 of file Tau.cc.

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

                                                                           {
   return pfSpecific().isolationPiZeroCandidates_;
 }

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

virtual

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

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

Reimplemented from reco::BaseTau.

Definition at line 166 of file Tau.cc.

References embeddedIsolationTracks_, i, reco::BaseTau::isolationTracks(), isolationTracks_, isolationTracksTransientRefVector_, isolationTracksTransientRefVectorFixed_, edm::RefVector< C, T, F >::push_back(), and edm::RefVector< C, T, F >::swap().

                                                       {
   if (embeddedIsolationTracks_) {
     if (!isolationTracksTransientRefVectorFixed_) {
         reco::TrackRefVector trackRefVec;
         for (unsigned int i = 0; i < isolationTracks_.size(); i++) {
           trackRefVec.push_back(reco::TrackRef(&isolationTracks_, i));
         }
         isolationTracksTransientRefVector_.swap(trackRefVec);
         isolationTracksTransientRefVectorFixed_ = true;
     }
     return isolationTracksTransientRefVector_;
   } else {
     return reco::BaseTau::isolationTracks();
   }
 }

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 142 of file Tau.h.

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

142 { return caloSpecific().isolationTracksPtSum_; }

pat::tau::TauCaloSpecific::isolationTracksPtSum_

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

return CaloTau info or throw exception 'not CaloTau'

Definition: Tau.cc:283

float isolationTracksPtSum_

Definition: TauCaloSpecific.h:33

bool pat::Tau::isPFTau ( ) const

inline

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

Definition at line 152 of file Tau.h.

References pfSpecific_.

Referenced by embedIsolationPFCands(), embedIsolationPFChargedHadrCands(), embedIsolationPFGammaCands(), embedIsolationPFNeutralHadrCands(), embedLeadPFCand(), embedLeadPFChargedHadrCand(), embedLeadPFNeutralCand(), embedSignalPFCands(), embedSignalPFChargedHadrCands(), embedSignalPFGammaCands(), embedSignalPFNeutralHadrCands(), etaetaMoment(), etaphiMoment(), p4Jet(), pfSpecific(), phiphiMoment(), pat::PATTauProducer::produce(), and setDecayMode().

152 { return !pfSpecific_.empty(); }

pat::Tau::pfSpecific_

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

holder for PFTau info, or empty vector if CaloTau

Definition: Tau.h:403

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

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

Definition at line 270 of file Tau.cc.

References tauIDs_.

                                                        {
   for (std::vector<IdPair>::const_iterator it = tauIDs_.begin(), ed = tauIDs_.end(); it != ed; ++it) {
     if (it->first == name) return true;
   }
   return false;
 }

float 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

Definition at line 627 of file Tau.cc.

References edm::hlt::Exception, jec_, and runtimedef::set().

Referenced by correctedTauJet().

 {
   for ( unsigned int idx = 0; idx < jec_.size(); ++idx ) {
     if ( set.empty() || jec_.at(idx).jecSet() == set ){
       if ( jec_[idx].jecLevel(level) >= 0 ) 
     return jecFactor(jec_[idx].jecLevel(level), idx);
       else
     throw cms::Exception("InvalidRequest") 
       << "This JEC level " << level << " does not exist. \n";
     }
   }
   throw cms::Exception("InvalidRequest") 
     << "This jet does not carry any jet energy correction factor information \n"
     << "for a jet energy correction set with label " << set << "\n";
 }

float 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

Definition at line 645 of file Tau.cc.

References currentJECLevel_, currentJECSet_, edm::hlt::Exception, jec_, jecSetAvailable(), and jecSetsAvailable().

 {
   if ( !jecSetsAvailable() )
     throw cms::Exception("InvalidRequest") 
       << "This jet does not carry any jet energy correction factor information \n";
   if ( !jecSetAvailable(set) )
     throw cms::Exception("InvalidRequest") 
       << "This jet does not carry any jet energy correction factor information \n"
       << "for a jet energy correction set with index " << set << "\n";
   return jec_.at(set).correction(level)/jec_.at(currentJECSet_).correction(currentJECLevel_);
 }

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

protected

return true if this jet carries the jet correction factors of a different set, for systematic studies

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

Definition at line 600 of file Tau.cc.

References jec_, and runtimedef::set().

Referenced by availableJECLevels(), and jecSetAvailable().

 {
   for ( std::vector<pat::TauJetCorrFactors>::const_iterator corrFactor = jec_.begin(); 
     corrFactor != jec_.end(); ++corrFactor ) {
     if ( corrFactor->jecSet() == set ) return corrFactor-jec_.begin(); 
   }
   return -1;
 }

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 290 of file Tau.h.

References jecSet().

Referenced by jecFactor().

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

pat::Tau::jecSet

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

return true if this jet carries the jet correction factors of a different set, for systematic studies...

Definition: Tau.cc:600

void set(const std::string &name, int value)

set the flag, with a run-time name

Definition: ProfilingTools.cc:67

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 293 of file Tau.h.

References jec_.

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

pat::Tau::jec_

std::vector< pat::TauJetCorrFactors > jec_

Definition: Tau.h:409

pat::tau::TauPFSpecific::leadPFChargedHadrCandsignedSipt_

void set(const std::string &name, int value)

set the flag, with a run-time name

Definition: ProfilingTools.cc:67

bool pat::Tau::jecSetsAvailable ( ) const

inline

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

Definition at line 287 of file Tau.h.

References jec_.

Referenced by jecFactor().

287 { return !jec_.empty(); }

pat::Tau::jec_

std::vector< pat::TauJetCorrFactors > jec_

Definition: Tau.h:409

const reco::PFCandidateRef Tau::leadPFCand ( ) const

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

Definition at line 453 of file Tau.cc.

References embeddedLeadPFCand_, pat::tau::TauPFSpecific::leadPFCand_, leadPFCand_, and pfSpecific().

                                                { 
   if(!embeddedLeadPFCand_)
     return pfSpecific().leadPFCand_;
   else
     return reco::PFCandidateRef(&leadPFCand_,0);
 }

const reco::PFCandidateRef Tau::leadPFChargedHadrCand ( ) const

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

Definition at line 439 of file Tau.cc.

References embeddedLeadPFChargedHadrCand_, pat::tau::TauPFSpecific::leadPFChargedHadrCand_, leadPFChargedHadrCand_, and pfSpecific().

                                                           { 
   if(!embeddedLeadPFChargedHadrCand_)
     return pfSpecific().leadPFChargedHadrCand_; 
   else
     return reco::PFCandidateRef(&leadPFChargedHadrCand_,0);
 }

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 163 of file Tau.h.

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

163 { return pfSpecific().leadPFChargedHadrCandsignedSipt_; }

float leadPFChargedHadrCandsignedSipt_

Definition: TauPFSpecific.h:29

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

const reco::PFCandidateRef Tau::leadPFNeutralCand ( ) const

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

Definition at line 446 of file Tau.cc.

References embeddedLeadPFNeutralCand_, pat::tau::TauPFSpecific::leadPFNeutralCand_, leadPFNeutralCand_, and pfSpecific().

                                                       { 
   if(!embeddedLeadPFNeutralCand_)
     return pfSpecific().leadPFNeutralCand_;
   else
     return reco::PFCandidateRef(&leadPFNeutralCand_,0);
 }

reco::TrackRef Tau::leadTrack ( ) const

virtual

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

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

Reimplemented from reco::BaseTau.

Definition at line 184 of file Tau.cc.

References embeddedLeadTrack_, reco::BaseTau::leadTrack(), and leadTrack_.

                                   {
   if (embeddedLeadTrack_) {
     return reco::TrackRef(&leadTrack_, 0);
   } else {
     return reco::BaseTau::leadTrack();
   }
 }

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 130 of file Tau.h.

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

130 { return caloSpecific().leadTrackHCAL3x3hitsEtSum_; }

pat::tau::TauCaloSpecific::leadTrackHCAL3x3hitsEtSum_

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

return CaloTau info or throw exception 'not CaloTau'

Definition: Tau.cc:283

float leadTrackHCAL3x3hitsEtSum_

Definition: TauCaloSpecific.h:29

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 133 of file Tau.h.

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

133 { return caloSpecific().leadTrackHCAL3x3hottesthitDEta_; }

pat::tau::TauCaloSpecific::leadTrackHCAL3x3hottesthitDEta_

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

return CaloTau info or throw exception 'not CaloTau'

Definition: Tau.cc:283

float leadTrackHCAL3x3hottesthitDEta_

Definition: TauCaloSpecific.h:30

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 127 of file Tau.h.

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

127 { return caloSpecific().leadTracksignedSipt_; }

pat::tau::TauCaloSpecific::leadTracksignedSipt_

float leadTracksignedSipt_

Definition: TauCaloSpecific.h:28

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

return CaloTau info or throw exception 'not CaloTau'

Definition: Tau.cc:283

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 148 of file Tau.h.

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

148 { return caloSpecific().maximumHCALhitEt_; }

pat::tau::TauCaloSpecific::maximumHCALhitEt_

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

return CaloTau info or throw exception 'not CaloTau'

Definition: Tau.cc:283

float maximumHCALhitEt_

Definition: TauCaloSpecific.h:35

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 208 of file Tau.h.

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

208 { return pfSpecific().maximumHCALPFClusterEt_; }

pat::tau::TauPFSpecific::maximumHCALPFClusterEt_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

float maximumHCALPFClusterEt_

Definition: TauPFSpecific.h:44

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 244 of file Tau.h.

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

244 { return pfSpecific().muonDecision_; }

pat::tau::TauPFSpecific::muonDecision_

bool muonDecision_

Definition: TauPFSpecific.h:58

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

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

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

Definition at line 288 of file Tau.cc.

References caloSpecific(), edm::hlt::Exception, isCaloTau(), isPFTau(), pat::tau::TauCaloSpecific::p4Jet_, pat::tau::TauPFSpecific::p4Jet_, and pfSpecific().

 {
   if ( isCaloTau() ) return caloSpecific().p4Jet_;
   if ( isPFTau()   ) return pfSpecific().p4Jet_;
   throw cms::Exception("Type Error") << "Requesting a CaloTau/PFTau-specific information from a pat::Tau which wasn't made from either a CaloTau or a PFTau.\n";
 }

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 157 of file Tau.h.

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

157 { return pfSpecific().pfJetRef_; }

pat::tau::TauPFSpecific::pfJetRef_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

reco::PFJetRef pfJetRef_

Definition: TauPFSpecific.h:27

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

return PFTau info or throw exception 'not PFTau'

Definition at line 278 of file Tau.cc.

References edm::hlt::Exception, isPFTau(), and pfSpecific_.

Referenced by bremsRecoveryEOverPLead(), caloComp(), decayMode(), ecalStripSumEOverPLead(), electronPreIDDecision(), electronPreIDOutput(), electronPreIDTrack(), emFraction(), etaetaMoment(), etaphiMoment(), hcal3x3OverPLead(), hcalMaxOverPLead(), hcalTotOverPLead(), isolationPFCands(), isolationPFChargedHadrCands(), isolationPFChargedHadrCandsPtSum(), isolationPFGammaCands(), isolationPFGammaCandsEtSum(), isolationPFNeutrHadrCands(), isolationPiZeroCandidates(), leadPFCand(), leadPFChargedHadrCand(), leadPFChargedHadrCandsignedSipt(), leadPFNeutralCand(), maximumHCALPFClusterEt(), muonDecision(), p4Jet(), pfJetRef(), phiphiMoment(), segComp(), signalPFCands(), signalPFChargedHadrCands(), signalPFGammaCands(), signalPFNeutrHadrCands(), and signalPiZeroCandidates().

                                                   {
   if (!isPFTau()) throw cms::Exception("Type Error") << "Requesting a PFTau-specific information from a pat::Tau which wasn't made from a PFTau.\n";
   return pfSpecific_[0]; 
 }

float Tau::phiphiMoment ( ) const

Definition at line 302 of file Tau.cc.

References caloSpecific(), edm::hlt::Exception, isCaloTau(), isPFTau(), pfSpecific(), pat::tau::TauCaloSpecific::phiphiMoment_, and pat::tau::TauPFSpecific::phiphiMoment_.

 {
   if ( isCaloTau() ) return caloSpecific().phiphiMoment_;
   if ( isPFTau()   ) return pfSpecific().phiphiMoment_;
   throw cms::Exception("Type Error") << "Requesting a CaloTau/PFTau-specific information from a pat::Tau which wasn't made from either a CaloTau or a PFTau.\n";
 }

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 241 of file Tau.h.

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

241 { return pfSpecific().segComp_; }

pat::tau::TauPFSpecific::segComp_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:278

float segComp_

Definition: TauPFSpecific.h:57

void Tau::setDecayMode ( int decayMode )

set decay mode

Definition at line 316 of file Tau.cc.

References decayMode(), edm::hlt::Exception, isPFTau(), and pfSpecific_.

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

 {
   if (!isPFTau()) throw cms::Exception("Type Error") << "Requesting a PFTau-specific information from a pat::Tau which wasn't made from a PFTau.\n";
   pfSpecific_[0].decayMode_ = decayMode;
 } 

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

set the matched GenJet

method to set the matched generated jet

Definition at line 244 of file Tau.cc.

References genJet_.

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

                                            {
   genJet_.clear();
   genJet_.push_back(*gj);
 }

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 273 of file Tau.h.

References tauIDs_.

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

273 { tauIDs_ = ids; }

pat::Tau::tauIDs_

std::vector< IdPair > tauIDs_

Definition: Tau.h:395

const reco::PFCandidateRefVector & Tau::signalPFCands ( ) const

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

Definition at line 460 of file Tau.cc.

References embeddedSignalPFCands_, i, pfSpecific(), edm::RefVector< C, T, F >::push_back(), pat::tau::TauPFSpecific::selectedSignalPFCands_, signalPFCands_, signalPFCandsRefVectorFixed_, signalPFCandsTransientRefVector_, and edm::RefVector< C, T, F >::swap().

                                                           { 
   if (embeddedSignalPFCands_) {
     if (!signalPFCandsRefVectorFixed_) {
       reco::PFCandidateRefVector aRefVec;
       for (unsigned int i = 0; i < signalPFCands_.size(); i++) {
     aRefVec.push_back(reco::PFCandidateRef(&signalPFCands_, i) );
       }
       signalPFCandsTransientRefVector_.swap(aRefVec);
       signalPFCandsRefVectorFixed_ = true;
     }
     return signalPFCandsTransientRefVector_;
   } else
     return pfSpecific().selectedSignalPFCands_; 
 }

const reco::PFCandidateRefVector & Tau::signalPFChargedHadrCands ( ) const

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

Definition at line 475 of file Tau.cc.

References embeddedSignalPFChargedHadrCands_, i, pfSpecific(), edm::RefVector< C, T, F >::push_back(), pat::tau::TauPFSpecific::selectedSignalPFChargedHadrCands_, signalPFChargedHadrCands_, signalPFChargedHadrCandsRefVectorFixed_, signalPFChargedHadrCandsTransientRefVector_, and edm::RefVector< C, T, F >::swap().

                                                                      {
   if (embeddedSignalPFChargedHadrCands_) {
     if (!signalPFChargedHadrCandsRefVectorFixed_) {
       reco::PFCandidateRefVector aRefVec;
       for (unsigned int i = 0; i < signalPFChargedHadrCands_.size(); i++) {
     aRefVec.push_back(reco::PFCandidateRef(&signalPFChargedHadrCands_, i) );
       }
       signalPFChargedHadrCandsTransientRefVector_.swap(aRefVec);
       signalPFChargedHadrCandsRefVectorFixed_ = true;
     }
     return signalPFChargedHadrCandsTransientRefVector_;
   } else
     return pfSpecific().selectedSignalPFChargedHadrCands_;
 } 

const reco::PFCandidateRefVector & Tau::signalPFGammaCands ( ) const

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

Definition at line 505 of file Tau.cc.

References embeddedSignalPFGammaCands_, i, pfSpecific(), edm::RefVector< C, T, F >::push_back(), pat::tau::TauPFSpecific::selectedSignalPFGammaCands_, signalPFGammaCands_, signalPFGammaCandsRefVectorFixed_, signalPFGammaCandsTransientRefVector_, and edm::RefVector< C, T, F >::swap().

                                                                {
   if (embeddedSignalPFGammaCands_) {
     if (!signalPFGammaCandsRefVectorFixed_) {
       reco::PFCandidateRefVector aRefVec;
       for (unsigned int i = 0; i < signalPFGammaCands_.size(); i++) {
     aRefVec.push_back(reco::PFCandidateRef(&signalPFGammaCands_, i) );
       }
       signalPFGammaCandsTransientRefVector_.swap(aRefVec);
       signalPFGammaCandsRefVectorFixed_ = true;
     }
     return signalPFGammaCandsTransientRefVector_;
   } else
     return pfSpecific().selectedSignalPFGammaCands_;
 }

const reco::PFCandidateRefVector & Tau::signalPFNeutrHadrCands ( ) const

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

Definition at line 490 of file Tau.cc.

References embeddedSignalPFNeutralHadrCands_, i, pfSpecific(), edm::RefVector< C, T, F >::push_back(), pat::tau::TauPFSpecific::selectedSignalPFNeutrHadrCands_, signalPFNeutralHadrCands_, signalPFNeutralHadrCandsRefVectorFixed_, signalPFNeutralHadrCandsTransientRefVector_, and edm::RefVector< C, T, F >::swap().

                                                                    {
   if (embeddedSignalPFNeutralHadrCands_) {
     if (!signalPFNeutralHadrCandsRefVectorFixed_) {
       reco::PFCandidateRefVector aRefVec;
       for (unsigned int i = 0; i < signalPFNeutralHadrCands_.size(); i++) {
     aRefVec.push_back(reco::PFCandidateRef(&signalPFNeutralHadrCands_, i) );
       }
       signalPFNeutralHadrCandsTransientRefVector_.swap(aRefVec);
       signalPFNeutralHadrCandsRefVectorFixed_ = true;
     }
     return signalPFNeutralHadrCandsTransientRefVector_;
   } else
     return pfSpecific().selectedSignalPFNeutrHadrCands_;
 } 

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

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

Definition at line 520 of file Tau.cc.

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

                                                                        {
   return pfSpecific().signalPiZeroCandidates_;
 }

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

virtual

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

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

Reimplemented from reco::BaseTau.

Definition at line 194 of file Tau.cc.

References embeddedSignalTracks_, i, edm::RefVector< C, T, F >::push_back(), reco::BaseTau::signalTracks(), signalTracks_, signalTracksTransientRefVector_, signalTracksTransientRefVectorFixed_, and edm::RefVector< C, T, F >::swap().

                                                    {
   if (embeddedSignalTracks_) {
     reco::TrackRefVector trackRefVec;
     if (!signalTracksTransientRefVectorFixed_) {
         for (unsigned int i = 0; i < signalTracks_.size(); i++) {
           trackRefVec.push_back(reco::TrackRef(&signalTracks_, i));
         }
         signalTracksTransientRefVector_.swap(trackRefVec);
         signalTracksTransientRefVectorFixed_ = true;
     }
     return signalTracksTransientRefVector_;
   } else {
     return reco::BaseTau::signalTracks();
   }
 }

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 136 of file Tau.h.

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

136 { return caloSpecific().signalTracksInvariantMass_; }

pat::tau::TauCaloSpecific::signalTracksInvariantMass_

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

return CaloTau info or throw exception 'not CaloTau'

Definition: Tau.cc:283

float signalTracksInvariantMass_

Definition: TauCaloSpecific.h:31

float 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

Definition at line 256 of file Tau.cc.

References tauIDs_.

                                              {
   for (std::vector<IdPair>::const_iterator it = tauIDs_.begin(), ed = tauIDs_.end(); it != ed; ++it) {
     if (it->first == name) return it->second;
   }
   cms::Exception ex("Key not found");
   ex << "pat::Tau: the ID " << name << " can't be found in this pat::Tau.\n";
   ex << "The available IDs are: ";
   for (std::vector<IdPair>::const_iterator it = tauIDs_.begin(), ed = tauIDs_.end(); it != ed; ++it) {
     ex << "'" << it->first << "' ";
   }
   ex << ".\n";
   throw ex;
 }

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

inline

Definition at line 265 of file Tau.h.

References tauID().

Referenced by tauID().

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

mergeVDriftHistosByStation.name

string name

Definition: mergeVDriftHistosByStation.py:77

pat::Tau::tauID

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

Definition: Tau.cc:256

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 270 of file Tau.h.

References tauIDs_.

270 { return tauIDs_; }

pat::Tau::tauIDs_

std::vector< IdPair > tauIDs_

Definition: Tau.h:395

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 139 of file Tau.h.

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

139 { return caloSpecific().TracksInvariantMass_; }