Reference Manual

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

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

pat::tau::TauPFSpecific::caloComp_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

float caloComp_

Definition: TauPFSpecific.h:58

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

return CaloTau info or throw exception 'not CaloTau'

Definition at line 258 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 130 of file Tau.h.

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

130 { return caloSpecific().CaloTauTagInfoRef_; }

pat::tau::TauCaloSpecific::CaloTauTagInfoRef_

reco::CaloTauTagInfoRef CaloTauTagInfoRef_

Definition: TauCaloSpecific.h:25

pat::Tau::currentJECLevel_

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

return CaloTau info or throw exception 'not CaloTau'

Definition: Tau.cc:258

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

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 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 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 733 of file Tau.cc.

References edm::hlt::Exception, customizeTrackingMonitorSeedNumber::idx, and jec_.

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

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

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

References currentJECLevel_, and testEve_cfg::level.

419 { currentJECLevel_=level; };

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.

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 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 setDecayMode().

337 { return pfEssential().decayMode_; }

pat::tau::TauPFEssential::decayMode_

int decayMode_

Definition: TauPFEssential.h:30

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

Definition: Tau.cc:252

double 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_

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

Definition: Tau.cc:252

double dxy_

Definition: TauPFEssential.h:33

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

pat::tau::TauPFEssential::dxy_error_

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

Definition: Tau.cc:252

double dxy_error_

Definition: TauPFEssential.h:34

const reco::PFTauTransverseImpactParameter::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_; }

pat::tau::TauPFEssential::dxy_PCA_

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

Definition: Tau.cc:252

reco::PFTauTransverseImpactParameter::Point dxy_PCA_

Definition: TauPFEssential.h:32

double Tau::dxy_Sig ( ) const

Definition at line 270 of file Tau.cc.

References pfEssential().

 {
   if ( pfEssential().dxy_error_ != 0 ) return (pfEssential().dxy_/pfEssential().dxy_error_);
   else return 0.;
 }

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

pat::tau::TauPFSpecific::ecalStripSumEOverPLead_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

float ecalStripSumEOverPLead_

Definition: TauPFSpecific.h:52

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

pat::tau::TauPFSpecific::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'

Definition: Tau.cc:247

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'

Definition: Tau.cc:247

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'

Definition: Tau.cc:247

void Tau::embedIsolationPFCands ( )

method to store the isolation candidates internally

Definition at line 391 of file Tau.cc.

References embeddedIsolationPFCands_, i, isolationPFCands_, isPFTau(), and pfSpecific_.

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

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

void Tau::embedIsolationPFChargedHadrCands ( )

method to store the isolation charged hadrons candidates internally

Definition at line 402 of file Tau.cc.

References embeddedIsolationPFChargedHadrCands_, i, isolationPFChargedHadrCands_, isPFTau(), and pfSpecific_.

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

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

void Tau::embedIsolationPFGammaCands ( )

method to store the isolation gamma candidates internally

Definition at line 422 of file Tau.cc.

References embeddedIsolationPFGammaCands_, i, isolationPFGammaCands_, isPFTau(), and pfSpecific_.

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

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

void Tau::embedIsolationPFNeutralHadrCands ( )

method to store the isolation neutral hadrons candidates internally

Definition at line 412 of file Tau.cc.

References embeddedIsolationPFNeutralHadrCands_, i, isolationPFNeutralHadrCands_, isPFTau(), and pfSpecific_.

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

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

void Tau::embedIsolationTracks ( )

method to store the isolation tracks internally

Definition at line 181 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 317 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 328 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 339 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 192 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 350 of file Tau.cc.

References embeddedSignalPFCands_, i, isPFTau(), pfSpecific_, and signalPFCands_.

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

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

void Tau::embedSignalPFChargedHadrCands ( )

method to store the signal charged hadrons candidates internally

Definition at line 360 of file Tau.cc.

References embeddedSignalPFChargedHadrCands_, i, isPFTau(), pfSpecific_, and signalPFChargedHadrCands_.

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

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

void Tau::embedSignalPFGammaCands ( )

method to store the signal gamma candidates internally

Definition at line 380 of file Tau.cc.

References embeddedSignalPFGammaCands_, i, isPFTau(), pfSpecific_, and signalPFGammaCands_.

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

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

void Tau::embedSignalPFNeutralHadrCands ( )

method to store the signal neutral hadrons candidates internally

Definition at line 370 of file Tau.cc.

References embeddedSignalPFNeutralHadrCands_, i, isPFTau(), pfSpecific_, and signalPFNeutralHadrCands_.

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

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

void Tau::embedSignalTracks ( )

method to store the signal tracks internally

method to store the isolation tracks internally

Definition at line 202 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 227 of file Tau.h.

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

227 { return pfSpecific().emFraction_; }

float emFraction_

Definition: TauPFSpecific.h:48

pat::tau::TauPFEssential::flightLength_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

float Tau::etaetaMoment ( ) const

Definition at line 289 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 303 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";
 }

bool Tau::ExistIsolationCands ( ) const

Definition at line 804 of file Tau.cc.

References edm::PtrVectorBase::isNull(), isolationChargedHadrCandPtrs_, isolationGammaCandPtrs_, and isolationNeutralHadrCandPtrs_.

Referenced by isolationCands().

                                     {
   return !(isolationChargedHadrCandPtrs_.isNull() && isolationNeutralHadrCandPtrs_.isNull() && isolationGammaCandPtrs_.isNull());
 }

bool Tau::ExistSignalCands ( ) const

check that there is at least one non-zero collection of candidate ptrs

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

Definition at line 800 of file Tau.cc.

References edm::PtrVectorBase::isNull(), signalChargedHadrCandPtrs_, signalGammaCandPtrs_, and signalNeutralHadrCandPtrs_.

Referenced by leadCand(), numberOfSourceCandidatePtrs(), signalCands(), and sourceCandidatePtr().

                                  {
   return !(signalChargedHadrCandPtrs_.isNull() && signalNeutralHadrCandPtrs_.isNull() && signalGammaCandPtrs_.isNull());
 }

const reco::PFTauTransverseImpactParameter::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_; }

reco::PFTauTransverseImpactParameter::Vector flightLength_

Definition: TauPFEssential.h:40

pat::tau::TauPFEssential::flightLengthSig_

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

Definition: Tau.cc:252

reco::PFTauTransverseImpactParameter::CovMatrix Tau::flightLengthCov ( ) const

Definition at line 276 of file Tau.cc.

References reco::Candidate::dimension, i, j, primaryVertexCov(), and secondaryVertexCov().

 {
   reco::PFTauTransverseImpactParameter::CovMatrix cov;
   const reco::PFTauTransverseImpactParameter::CovMatrix& sv = secondaryVertexCov();
   const reco::PFTauTransverseImpactParameter::CovMatrix& pv = primaryVertexCov();
   for ( int i = 0; i < dimension; ++i ) {
     for ( int j = 0; j < dimension; ++j ) {
       cov(i,j) = sv(i,j) + pv(i,j);
     }
   }
   return cov;
 }

double pat::Tau::flightLengthSig ( ) const

inline

Definition at line 323 of file Tau.h.

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

323 { return pfEssential().flightLengthSig_; }

double flightLengthSig_

Definition: TauPFEssential.h:41

pat::tau::TauPFEssential::hasSV_

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

Definition: Tau.cc:252

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 219 of file Tau.cc.

References genJet_.

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

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

bool hasSV_

Definition: TauPFEssential.h:39

pat::tau::TauPFSpecific::hcal3x3OverPLead_

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

Definition: Tau.cc:252

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'

Definition: Tau.cc:247

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

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

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

pat::tau::TauPFSpecific::hcalTotOverPLead_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

float hcalTotOverPLead_

Definition: TauPFSpecific.h:49

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

References caloSpecific_.

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

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 Tau::isolationCands ( ) const

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

the isolationCands pointers are not saved in miniAOD, so the collection is created dynamically by glueing together 3 sub-collection and re-ordering

Definition at line 877 of file Tau.cc.

References ExistIsolationCands(), first, isolationChargedHadrCandPtrs_, isolationGammaCandPtrs_, isolationNeutralHadrCandPtrs_, isolationPFCands(), reco::LeafCandidate::p(), edm::PtrVector< T >::push_back(), run_regression::ret, and python.multivaluedict::sort().

                                                  {
   std::vector<reco::PFCandidatePtr> r0 = isolationPFCands();
   reco::CandidatePtrVector ret;
   if(!Tau::ExistIsolationCands() || (!r0.empty() && r0.front().isAvailable())) {
     for (const auto & p : r0) ret.push_back(p);
     return ret;
   } else {
     reco::CandidatePtrVector ret2;
     std::vector<std::pair<float,size_t> > pt_index;
     size_t index=0;
     for (const auto & p : isolationChargedHadrCandPtrs_){ ret2.push_back(p); pt_index.push_back(std::make_pair(p->pt(),index)); index++;}
     for (const auto & p : isolationNeutralHadrCandPtrs_){ ret2.push_back(p); pt_index.push_back(std::make_pair(p->pt(),index)); index++;}
     for (const auto & p : isolationGammaCandPtrs_){ ret2.push_back(p); pt_index.push_back(std::make_pair(p->pt(),index)); index++;}
     std::sort(pt_index.begin(),pt_index.end(),
           boost::bind(&std::pair<float,size_t>::first,_1) >
           boost::bind(&std::pair<float,size_t>::first,_2));
     for( const auto & p : pt_index){
       ret.push_back(ret2[p.second]);
     }
     return ret;
   }
 }

reco::CandidatePtrVector Tau::isolationChargedHadrCands ( ) const

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

Definition at line 903 of file Tau.cc.

References edm::PtrVectorBase::isNull(), isolationChargedHadrCandPtrs_, isolationPFChargedHadrCands(), reco::LeafCandidate::p(), edm::PtrVector< T >::push_back(), and run_regression::ret.

                                                             {
    std::vector<reco::PFCandidatePtr> r0 = isolationPFChargedHadrCands();
    if(isolationChargedHadrCandPtrs_.isNull() || (!r0.empty() && r0.front().isAvailable())) {
         reco::CandidatePtrVector ret;
         for (const auto & p : r0) ret.push_back(p);
     return ret;
    } else {
         return isolationChargedHadrCandPtrs_;
    }
 }

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'

Definition: Tau.cc:258

float isolationECALhitsEtSum_

Definition: TauCaloSpecific.h:32

reco::CandidatePtrVector Tau::isolationGammaCands ( ) const

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

Definition at line 930 of file Tau.cc.

References edm::PtrVectorBase::isNull(), isolationGammaCandPtrs_, isolationPFGammaCands(), reco::LeafCandidate::p(), edm::PtrVector< T >::push_back(), and run_regression::ret.

                                                       {
    std::vector<reco::PFCandidatePtr> r0 = isolationPFGammaCands();
    if(isolationGammaCandPtrs_.isNull() || (!r0.empty() && r0.front().isAvailable())) {
         reco::CandidatePtrVector ret;
         for (const auto & p : r0) ret.push_back(p);
     return ret;
    } else {
         return isolationGammaCandPtrs_;
    }
 }

reco::CandidatePtrVector Tau::isolationNeutrHadrCands ( ) const

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

Definition at line 916 of file Tau.cc.

References edm::PtrVectorBase::isNull(), isolationNeutralHadrCandPtrs_, isolationPFNeutrHadrCands(), reco::LeafCandidate::p(), edm::PtrVector< T >::push_back(), and run_regression::ret.

                                                           {
    reco::CandidatePtrVector ret;
    std::vector<reco::PFCandidatePtr> r0 = isolationPFNeutrHadrCands();
    if(isolationNeutralHadrCandPtrs_.isNull() || (!r0.empty() && r0.front().isAvailable())) {
         reco::CandidatePtrVector ret;
         for (const auto & p : r0) ret.push_back(p);
     return ret;
    } else {
         return isolationNeutralHadrCandPtrs_;
    }
 }

const std::vector< reco::PFCandidatePtr > & 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 564 of file Tau.cc.

References embeddedIsolationPFCands_, i, isolationPFCands_, isolationPFCandsTransientPtrs_, edm::AtomicPtrCache< T >::isSet(), pfSpecific(), pfSpecific_, pat::tau::TauPFSpecific::selectedIsolationPFCands_, and edm::AtomicPtrCache< T >::set().

Referenced by isolationCands().

                                                                  {
   if (embeddedIsolationPFCands_) {
   if (!isolationPFCandsTransientPtrs_.isSet()) {
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{ new std::vector<reco::PFCandidatePtr>{}};
       aPtrs->reserve(isolationPFCands_.size());
       for (unsigned int i = 0; i < isolationPFCands_.size(); i++) {
     aPtrs->push_back(reco::PFCandidatePtr(&isolationPFCands_, i) );
       }
       isolationPFCandsTransientPtrs_.set(std::move(aPtrs));
     }
     return *isolationPFCandsTransientPtrs_;
   } else {
     if(pfSpecific_.empty() || pfSpecific().selectedIsolationPFCands_.empty() || !pfSpecific().selectedIsolationPFCands_.front().isAvailable()){
       // this part of code is called when reading from patTuple or miniAOD
       // it returns empty collection in correct format so it can be substituted by reco::Candidates if available
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{new std::vector<reco::PFCandidatePtr>{}};
       isolationPFCandsTransientPtrs_.set(std::move(aPtrs));
       return *isolationPFCandsTransientPtrs_;
     } else return pfSpecific().selectedIsolationPFCands_;
   }
 } 

const std::vector< reco::PFCandidatePtr > & 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 586 of file Tau.cc.

References embeddedIsolationPFChargedHadrCands_, i, isolationPFChargedHadrCands_, isolationPFChargedHadrCandsTransientPtrs_, edm::AtomicPtrCache< T >::isSet(), pfSpecific(), pfSpecific_, pat::tau::TauPFSpecific::selectedIsolationPFChargedHadrCands_, and edm::AtomicPtrCache< T >::set().

Referenced by isolationChargedHadrCands(), and pat::PATTauSlimmer::produce().

                                                                             {
   if (embeddedIsolationPFChargedHadrCands_) {
    if (!isolationPFChargedHadrCandsTransientPtrs_.isSet()) {
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{ new std::vector<reco::PFCandidatePtr>{}};
       aPtrs->reserve(isolationPFChargedHadrCands_.size());
       for (unsigned int i = 0; i < isolationPFChargedHadrCands_.size(); i++) {
     aPtrs->push_back(reco::PFCandidatePtr(&isolationPFChargedHadrCands_, i) );
       }
       isolationPFChargedHadrCandsTransientPtrs_.set(std::move(aPtrs));
     }
     return *isolationPFChargedHadrCandsTransientPtrs_;
   } else {
     if(pfSpecific_.empty() || pfSpecific().selectedIsolationPFChargedHadrCands_.empty() || !pfSpecific().selectedIsolationPFChargedHadrCands_.front().isAvailable()){
       // this part of code is called when reading from patTuple or miniAOD
       // it returns empty collection in correct format so it can be substituted by reco::Candidates if available
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{new std::vector<reco::PFCandidatePtr>{}};
       isolationPFChargedHadrCandsTransientPtrs_.set(std::move(aPtrs));
       return *isolationPFChargedHadrCandsTransientPtrs_;
     } 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 218 of file Tau.h.

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

218 { return pfSpecific().isolationPFChargedHadrCandsPtSum_; }

pat::tau::TauPFSpecific::isolationPFChargedHadrCandsPtSum_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

float isolationPFChargedHadrCandsPtSum_

Definition: TauPFSpecific.h:44

const std::vector< reco::PFCandidatePtr > & 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 630 of file Tau.cc.

References embeddedIsolationPFGammaCands_, i, isolationPFGammaCands_, isolationPFGammaCandsTransientPtrs_, edm::AtomicPtrCache< T >::isSet(), pfSpecific(), pfSpecific_, pat::tau::TauPFSpecific::selectedIsolationPFGammaCands_, and edm::AtomicPtrCache< T >::set().

Referenced by isolationGammaCands(), and pat::PATTauSlimmer::produce().

                                                                       {
   if (embeddedIsolationPFGammaCands_) {
     if (!isolationPFGammaCandsTransientPtrs_.isSet()) {
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{new std::vector<reco::PFCandidatePtr>{}};
       aPtrs->reserve(isolationPFGammaCands_.size());
       for (unsigned int i = 0; i < isolationPFGammaCands_.size(); i++) {
     aPtrs->push_back(reco::PFCandidatePtr(&isolationPFGammaCands_, i) );
       }
       isolationPFGammaCandsTransientPtrs_.set(std::move(aPtrs));
     }
     return *isolationPFGammaCandsTransientPtrs_;
   } else {
     if(pfSpecific_.empty() || pfSpecific().selectedIsolationPFGammaCands_.empty() || !pfSpecific().selectedIsolationPFGammaCands_.front().isAvailable()){
       // this part of code is called when reading from patTuple or miniAOD
       // it returns empty collection in correct format so it can be substituted by reco::Candidates if available
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{new std::vector<reco::PFCandidatePtr>{}};
       isolationPFGammaCandsTransientPtrs_.set(std::move(aPtrs));
       return *isolationPFGammaCandsTransientPtrs_;
     } 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 221 of file Tau.h.

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

221 { return pfSpecific().isolationPFGammaCandsEtSum_; }

pat::tau::TauPFSpecific::isolationPFGammaCandsEtSum_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

float isolationPFGammaCandsEtSum_

Definition: TauPFSpecific.h:45

const std::vector< reco::PFCandidatePtr > & 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 608 of file Tau.cc.

References embeddedIsolationPFNeutralHadrCands_, i, isolationPFNeutralHadrCands_, isolationPFNeutralHadrCandsTransientPtrs_, edm::AtomicPtrCache< T >::isSet(), pfSpecific(), pfSpecific_, pat::tau::TauPFSpecific::selectedIsolationPFNeutrHadrCands_, and edm::AtomicPtrCache< T >::set().

Referenced by isolationNeutrHadrCands(), and pat::PATTauSlimmer::produce().

                                                                           {
   if (embeddedIsolationPFNeutralHadrCands_) {
     if (!isolationPFNeutralHadrCandsTransientPtrs_.isSet()) {
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{ new std::vector<reco::PFCandidatePtr>{}};
       aPtrs->reserve(isolationPFNeutralHadrCands_.size());
       for (unsigned int i = 0; i < isolationPFNeutralHadrCands_.size(); i++) {
     aPtrs->push_back(reco::PFCandidatePtr(&isolationPFNeutralHadrCands_, i) );
       }
       isolationPFNeutralHadrCandsTransientPtrs_.set(std::move(aPtrs));
     }
     return *isolationPFNeutralHadrCandsTransientPtrs_;
   } else {
     if(pfSpecific_.empty() || pfSpecific().selectedIsolationPFNeutrHadrCands_.empty() || !pfSpecific().selectedIsolationPFNeutrHadrCands_.front().isAvailable()){
       // this part of code is called when reading from patTuple or miniAOD
       // it returns empty collection in correct format so it can be substituted by reco::Candidates if available
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{new std::vector<reco::PFCandidatePtr>{}};
       isolationPFNeutralHadrCandsTransientPtrs_.set(std::move(aPtrs));
       return *isolationPFNeutralHadrCandsTransientPtrs_;
     } 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 657 of file Tau.cc.

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

                                                                           {
   if(pfSpecific_.empty()) throw cms::Exception("Type Error") << "Requesting content that is not stored in miniAOD.\n";
   return pfSpecific().isolationPiZeroCandidates_;
 }

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

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

Definition at line 652 of file Tau.cc.

References pat::tau::TauPFSpecific::isolationTauChargedHadronCandidates_, pfSpecific(), and pfSpecific_.

                                                                                              {
   if(pfSpecific_.empty()) throw cms::Exception("Type Error") << "Requesting content that is not stored in miniAOD.\n";
   return pfSpecific().isolationTauChargedHadronCandidates_;
 }

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 135 of file Tau.cc.

References embeddedIsolationTracks_, i, reco::BaseTau::isolationTracks(), isolationTracks_, isolationTracksTransientRefVector_, edm::AtomicPtrCache< T >::isSet(), edm::RefVector< C, T, F >::reserve(), and edm::AtomicPtrCache< T >::set().

                                                       {
   if (embeddedIsolationTracks_) {
     if (!isolationTracksTransientRefVector_.isSet()) {
     std::unique_ptr<reco::TrackRefVector> trackRefVec{ new reco::TrackRefVector{}};
     trackRefVec->reserve(isolationTracks_.size());
         for (unsigned int i = 0; i < isolationTracks_.size(); i++) {
           trackRefVec->push_back(reco::TrackRef(&isolationTracks_, i));
         }
     isolationTracksTransientRefVector_.set(std::move(trackRefVec));
     }
     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 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'

Definition: Tau.cc:258

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 embedIsolationPFCands(), embedIsolationPFChargedHadrCands(), embedIsolationPFGammaCands(), embedIsolationPFNeutralHadrCands(), embedLeadPFCand(), embedLeadPFChargedHadrCand(), embedLeadPFNeutralCand(), embedSignalPFCands(), embedSignalPFChargedHadrCands(), embedSignalPFGammaCands(), embedSignalPFNeutralHadrCands(), etaetaMoment(), etaphiMoment(), leadTauChargedHadronCandidate(), p4Jet(), pfSpecific(), phiphiMoment(), pat::PATTauProducer::produce(), and setDecayMode().

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 Tau::isTauIDAvailable ( const std::string & name ) const

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

Definition at line 239 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 701 of file Tau.cc.

References edm::hlt::Exception, customizeTrackingMonitorSeedNumber::idx, and jec_.

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 719 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 674 of file Tau.cc.

References jec_.

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

References jecSet().

Referenced by jecFactor().

373 {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:674

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_.

Referenced by jecFactor().

370 { return !jec_.empty(); }

pat::Tau::jec_

std::vector< pat::TauJetCorrFactors > jec_

Definition: Tau.h:487

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

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

Definition at line 792 of file Tau.cc.

References ExistSignalCands(), edm::Ptr< T >::isAvailable(), leadPFCand(), and signalCands().

                                            {
     const reco::PFCandidatePtr leadPF = leadPFCand();
     if (leadPF.isAvailable() || !Tau::ExistSignalCands()) return leadPF;
     else return Tau::signalCands()[0];
 }

const reco::CandidatePtr 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

Definition at line 768 of file Tau.cc.

References edm::Ptr< T >::isAvailable(), edm::PtrVectorBase::isNull(), edm::Ptr< T >::isNull(), leadPFChargedHadrCand(), reco::LeafCandidate::p(), run_regression::ret, and signalChargedHadrCandPtrs_.

                                                       {
     const reco::PFCandidatePtr leadPF = leadPFChargedHadrCand();
     if (leadPF.isAvailable() || signalChargedHadrCandPtrs_.isNull()) return leadPF;
     reco::CandidatePtr ret;
     for (const reco::CandidatePtr & p : signalChargedHadrCandPtrs_) {
         if (ret.isNull() || (p->pt() > ret->pt())) ret = p;
     }
     return ret;
 
 }

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

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

Definition at line 780 of file Tau.cc.

References edm::Ptr< T >::isAvailable(), edm::PtrVectorBase::isNull(), edm::Ptr< T >::isNull(), leadPFNeutralCand(), reco::LeafCandidate::p(), run_regression::ret, and signalNeutralHadrCandPtrs_.

                                                   {
     const reco::PFCandidatePtr leadPF = leadPFNeutralCand();
     if (leadPF.isAvailable() || signalNeutralHadrCandPtrs_.isNull()) return leadPF;
     reco::CandidatePtr ret;
     for (const reco::CandidatePtr & p : signalNeutralHadrCandPtrs_) {
         if (ret.isNull() || (p->pt() > ret->pt())) ret = p;
     }
     return ret;
 
 }

const reco::PFCandidatePtr 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 458 of file Tau.cc.

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

Referenced by leadCand().

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

const reco::PFCandidatePtr 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 442 of file Tau.cc.

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

Referenced by leadChargedHadrCand().

                                                           { 
   if(!embeddedLeadPFChargedHadrCand_){
     if(pfSpecific_.empty()) return reco::PFCandidatePtr(); 
     else return pfSpecific().leadPFChargedHadrCand_; 
   }else
     return reco::PFCandidatePtr(&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 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'

Definition: Tau.cc:247

const reco::PFCandidatePtr 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 450 of file Tau.cc.

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

Referenced by leadNeutralCand().

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

reco::PFRecoTauChargedHadronRef Tau::leadTauChargedHadronCandidate ( ) const

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

Definition at line 433 of file Tau.cc.

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

                                                                        {
   if(!isPFTau() ) throw cms::Exception("Type Error") << "Requesting content that is not stored in miniAOD.\n";
   if ( pfSpecific().signalTauChargedHadronCandidates_.size() > 0 ) {
     return reco::PFRecoTauChargedHadronRef(&pfSpecific().signalTauChargedHadronCandidates_,0);
   } else {
     return reco::PFRecoTauChargedHadronRef();
   }
 }

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 153 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 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'

Definition: Tau.cc:258

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'

Definition: Tau.cc:258

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'

Definition: Tau.cc:258

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'

Definition: Tau.cc:258

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_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

float maximumHCALPFClusterEt_

Definition: TauPFSpecific.h:46

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

pat::tau::TauPFSpecific::muonDecision_

bool muonDecision_

Definition: TauPFSpecific.h:60

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

size_t Tau::numberOfSourceCandidatePtrs ( ) const

virtual

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

Reimplemented from reco::LeafCandidate.

Definition at line 945 of file Tau.cc.

References ExistSignalCands(), pfSpecific(), pfSpecific_, pat::tau::TauPFSpecific::selectedSignalPFCands_, signalCands(), and edm::PtrVectorBase::size().

                                               {
   if (Tau::ExistSignalCands()) return Tau::signalCands().size();
   else if(pfSpecific_.empty()) return 0; 
   else return pfSpecific().selectedSignalPFCands_.size();
 }

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 263 of file Tau.cc.

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

 {
   if ( isCaloTau() ) return caloSpecific().p4Jet_;
   if ( isPFTau()   ) return pfEssential().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 pat::tau::TauPFEssential & Tau::pfEssential ( ) const

Definition at line 252 of file Tau.cc.

References pfEssential_.

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

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

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().

164 { return pfSpecific().pfJetRef_; }

pat::tau::TauPFSpecific::pfJetRef_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

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 247 of file Tau.cc.

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

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

                                                   {
   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 296 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";
 }

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

pat::tau::TauPFEssential::pv_

reco::VertexRef pv_

Definition: TauPFEssential.h:36

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

Definition: Tau.cc:252

const reco::PFTauTransverseImpactParameter::CovMatrix& pat::Tau::primaryVertexCov ( ) const

inline

Definition at line 320 of file Tau.h.

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

Referenced by flightLengthCov().

320 { return pfEssential().pvCov_; }

pat::tau::TauPFEssential::pvCov_

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

Definition: Tau.cc:252

reco::PFTauTransverseImpactParameter::CovMatrix pvCov_

Definition: TauPFEssential.h:38

const reco::PFTauTransverseImpactParameter::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_

reco::PFTauTransverseImpactParameter::Point pvPos_

Definition: TauPFEssential.h:37

pat::tau::TauPFEssential::sv_

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

Definition: Tau.cc:252

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

reco::VertexRef sv_

Definition: TauPFEssential.h:42

pat::tau::TauPFEssential::svCov_

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

Definition: Tau.cc:252

const reco::PFTauTransverseImpactParameter::CovMatrix& pat::Tau::secondaryVertexCov ( ) const

inline

Definition at line 327 of file Tau.h.

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

Referenced by flightLengthCov().

327 { return pfEssential().svCov_; }

reco::PFTauTransverseImpactParameter::CovMatrix svCov_

Definition: TauPFEssential.h:44

pat::tau::TauPFEssential::svPos_

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

Definition: Tau.cc:252

const reco::PFTauTransverseImpactParameter::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_; }

reco::PFTauTransverseImpactParameter::Point svPos_

Definition: TauPFEssential.h:43

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

Definition: Tau.cc:252

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_

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

return PFTau info or throw exception 'not PFTau'

Definition: Tau.cc:247

float segComp_

Definition: TauPFSpecific.h:59

void Tau::setDecayMode ( int decayMode )

set decay mode

Definition at line 310 of file Tau.cc.

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

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";
   pfEssential_[0].decayMode_ = decayMode;
 } 

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

set the matched GenJet

method to set the matched generated jet

Definition at line 213 of file Tau.cc.

References genJet_.

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

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

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

pat::Tau::isolationChargedHadrCandPtrs_

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 Tau::signalCands ( ) const

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

the isolationCands pointers are not saved in miniAOD, so the collection is created dynamically by glueing together 3 sub-collection and re-ordering

Definition at line 811 of file Tau.cc.

References ExistSignalCands(), first, reco::LeafCandidate::p(), edm::PtrVector< T >::push_back(), run_regression::ret, signalChargedHadrCandPtrs_, signalGammaCandPtrs_, signalNeutralHadrCandPtrs_, signalPFCands(), and python.multivaluedict::sort().

Referenced by leadCand(), numberOfSourceCandidatePtrs(), and sourceCandidatePtr().

                                               {
     std::vector<reco::PFCandidatePtr> r0 = signalPFCands();
     reco::CandidatePtrVector ret;
     if(!Tau::ExistSignalCands() || (!r0.empty() && r0.front().isAvailable())) {
       for (const auto & p : r0) ret.push_back(p);
       return ret;
     } else {
       reco::CandidatePtrVector ret2;
       std::vector<std::pair<float,size_t> > pt_index;
       size_t index=0;
       for (const auto & p : signalChargedHadrCandPtrs_){ ret2.push_back(p); pt_index.push_back(std::make_pair(p->pt(),index)); index++;}
       for (const auto & p : signalNeutralHadrCandPtrs_){ ret2.push_back(p); pt_index.push_back(std::make_pair(p->pt(),index)); index++;}
       for (const auto & p : signalGammaCandPtrs_){ ret2.push_back(p); pt_index.push_back(std::make_pair(p->pt(),index)); index++;}
       std::sort(pt_index.begin(),pt_index.end(),
             boost::bind(&std::pair<float,size_t>::first,_1) >
         boost::bind(&std::pair<float,size_t>::first,_2));
       for( const auto & p : pt_index){
     ret.push_back(ret2[p.second]);
       }
       return ret;
     }
 }

reco::CandidatePtrVector Tau::signalChargedHadrCands ( ) const

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

Definition at line 837 of file Tau.cc.

References edm::PtrVectorBase::isNull(), reco::LeafCandidate::p(), edm::PtrVector< T >::push_back(), run_regression::ret, signalChargedHadrCandPtrs_, and signalPFChargedHadrCands().

                                                          {
    std::vector<reco::PFCandidatePtr> r0 = signalPFChargedHadrCands();
    if(signalChargedHadrCandPtrs_.isNull() || (!r0.empty() && r0.front().isAvailable())) {
         reco::CandidatePtrVector ret;
         for (const auto & p : r0) ret.push_back(p);
     return ret;
    } else {
         return signalChargedHadrCandPtrs_;
    }
 }

reco::CandidatePtrVector Tau::signalGammaCands ( ) const

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

Definition at line 864 of file Tau.cc.

References edm::PtrVectorBase::isNull(), reco::LeafCandidate::p(), edm::PtrVector< T >::push_back(), run_regression::ret, signalGammaCandPtrs_, and signalPFGammaCands().

                                                    {
    std::vector<reco::PFCandidatePtr> r0 = signalPFGammaCands();
    if(signalGammaCandPtrs_.isNull() || (!r0.empty() && r0.front().isAvailable())) {
         reco::CandidatePtrVector ret;
         for (const auto & p : r0) ret.push_back(p);
     return ret;
    } else {
         return signalGammaCandPtrs_;
    }
 }

reco::CandidatePtrVector Tau::signalNeutrHadrCands ( ) const

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

Definition at line 851 of file Tau.cc.

References edm::PtrVectorBase::isNull(), reco::LeafCandidate::p(), edm::PtrVector< T >::push_back(), run_regression::ret, signalNeutralHadrCandPtrs_, and signalPFNeutrHadrCands().

                                                        {
    std::vector<reco::PFCandidatePtr> r0 = signalPFNeutrHadrCands();
    if(signalNeutralHadrCandPtrs_.isNull() || (!r0.empty() && r0.front().isAvailable())) {
         reco::CandidatePtrVector ret;
         for (const auto & p : r0) ret.push_back(p);
     return ret;
    } else {
         return signalNeutralHadrCandPtrs_;
    }
 }

const std::vector< reco::PFCandidatePtr > & 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 466 of file Tau.cc.

References embeddedSignalPFCands_, i, edm::AtomicPtrCache< T >::isSet(), pfSpecific(), pfSpecific_, pat::tau::TauPFSpecific::selectedSignalPFCands_, edm::AtomicPtrCache< T >::set(), signalPFCands_, and signalPFCandsTransientPtrs_.

Referenced by signalCands().

                                                               { 
   if (embeddedSignalPFCands_) {
    if (!signalPFCandsTransientPtrs_.isSet()) {
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{new std::vector<reco::PFCandidatePtr>{}};
       aPtrs->reserve(signalPFCands_.size());
       for (unsigned int i = 0; i < signalPFCands_.size(); i++) {
     aPtrs->push_back(reco::PFCandidatePtr(&signalPFCands_, i) );
       }
       signalPFCandsTransientPtrs_.set(std::move(aPtrs));
     }
     return *signalPFCandsTransientPtrs_;
   } else {
     if(pfSpecific_.empty() || pfSpecific().selectedSignalPFCands_.empty() || !pfSpecific().selectedSignalPFCands_.front().isAvailable()){
       // this part of code is called when reading from patTuple or miniAOD
       // it returns empty collection in correct format so it can be substituted by reco::Candidates if available
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{new std::vector<reco::PFCandidatePtr>{}};
       signalPFCandsTransientPtrs_.set(std::move(aPtrs));
       return *signalPFCandsTransientPtrs_;
     } else return pfSpecific().selectedSignalPFCands_;
   }
 }

const std::vector< reco::PFCandidatePtr > & 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 488 of file Tau.cc.

References embeddedSignalPFChargedHadrCands_, i, edm::AtomicPtrCache< T >::isSet(), pfSpecific(), pfSpecific_, pat::tau::TauPFSpecific::selectedSignalPFChargedHadrCands_, edm::AtomicPtrCache< T >::set(), signalPFChargedHadrCands_, and signalPFChargedHadrCandsTransientPtrs_.

Referenced by pat::PATTauSlimmer::produce(), and signalChargedHadrCands().

                                                                          {
   if (embeddedSignalPFChargedHadrCands_) {
    if (!signalPFChargedHadrCandsTransientPtrs_.isSet()) {
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{ new std::vector<reco::PFCandidatePtr>{}};
       aPtrs->reserve(signalPFChargedHadrCands_.size());
       for (unsigned int i = 0; i < signalPFChargedHadrCands_.size(); i++) {
     aPtrs->push_back(reco::PFCandidatePtr(&signalPFChargedHadrCands_, i) );
       }
       signalPFChargedHadrCandsTransientPtrs_.set(std::move(aPtrs));
     }
     return *signalPFChargedHadrCandsTransientPtrs_;
   } else {
     if(pfSpecific_.empty() || pfSpecific().selectedSignalPFChargedHadrCands_.empty() || !pfSpecific().selectedSignalPFChargedHadrCands_.front().isAvailable()){
       // this part of code is called when reading from patTuple or miniAOD
       // it returns empty collection in correct format so it can be substituted by reco::Candidates if available
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{new std::vector<reco::PFCandidatePtr>{}};
       signalPFChargedHadrCandsTransientPtrs_.set(std::move(aPtrs));
       return *signalPFChargedHadrCandsTransientPtrs_;
     } else return pfSpecific().selectedSignalPFChargedHadrCands_;
   }
 } 

const std::vector< reco::PFCandidatePtr > & 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 532 of file Tau.cc.

References embeddedSignalPFGammaCands_, i, edm::AtomicPtrCache< T >::isSet(), pfSpecific(), pfSpecific_, pat::tau::TauPFSpecific::selectedSignalPFGammaCands_, edm::AtomicPtrCache< T >::set(), signalPFGammaCands_, and signalPFGammaCandsTransientPtrs_.

Referenced by pat::PATTauSlimmer::produce(), and signalGammaCands().

                                                                    {
   if (embeddedSignalPFGammaCands_) {
    if (!signalPFGammaCandsTransientPtrs_.isSet()) {
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{ new std::vector<reco::PFCandidatePtr>{}};
       aPtrs->reserve(signalPFGammaCands_.size());
       for (unsigned int i = 0; i < signalPFGammaCands_.size(); i++) {
     aPtrs->push_back(reco::PFCandidatePtr(&signalPFGammaCands_, i) );
       }
       signalPFGammaCandsTransientPtrs_.set(std::move(aPtrs));
     }
     return *signalPFGammaCandsTransientPtrs_;
   } else {
     if(pfSpecific_.empty() || pfSpecific().selectedSignalPFGammaCands_.empty() || !pfSpecific().selectedSignalPFGammaCands_.front().isAvailable()){
       // this part of code is called when reading from patTuple or miniAOD
       // it returns empty collection in correct format so it can be substituted by reco::Candidates if available
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{new std::vector<reco::PFCandidatePtr>{}};
       signalPFGammaCandsTransientPtrs_.set(std::move(aPtrs));
       return *signalPFGammaCandsTransientPtrs_;
     } else return pfSpecific().selectedSignalPFGammaCands_;
   }
 }

const std::vector< reco::PFCandidatePtr > & 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 510 of file Tau.cc.

References embeddedSignalPFNeutralHadrCands_, i, edm::AtomicPtrCache< T >::isSet(), pfSpecific(), pfSpecific_, pat::tau::TauPFSpecific::selectedSignalPFNeutrHadrCands_, edm::AtomicPtrCache< T >::set(), signalPFNeutralHadrCands_, and signalPFNeutralHadrCandsTransientPtrs_.

Referenced by pat::PATTauSlimmer::produce(), and signalNeutrHadrCands().

                                                                        {
   if (embeddedSignalPFNeutralHadrCands_) {
    if (!signalPFNeutralHadrCandsTransientPtrs_.isSet()) {
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{new std::vector<reco::PFCandidatePtr>{}};
       aPtrs->reserve(signalPFNeutralHadrCands_.size());
       for (unsigned int i = 0; i < signalPFNeutralHadrCands_.size(); i++) {
     aPtrs->push_back(reco::PFCandidatePtr(&signalPFNeutralHadrCands_, i) );
       }
       signalPFNeutralHadrCandsTransientPtrs_.set(std::move(aPtrs));
     }
     return *signalPFNeutralHadrCandsTransientPtrs_;
   } else {
     if(pfSpecific_.empty() || pfSpecific().selectedSignalPFNeutrHadrCands_.empty() || !pfSpecific().selectedSignalPFNeutrHadrCands_.front().isAvailable()){
       // this part of code is called when reading from patTuple or miniAOD
       // it returns empty collection in correct format so it can be substituted by reco::Candidates if available
       std::unique_ptr<std::vector<reco::PFCandidatePtr> > aPtrs{new std::vector<reco::PFCandidatePtr>{}};
       signalPFNeutralHadrCandsTransientPtrs_.set(std::move(aPtrs));
       return *signalPFNeutralHadrCandsTransientPtrs_;
     } 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 559 of file Tau.cc.

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

                                                                        {
   if(pfSpecific_.empty()) throw cms::Exception("Type Error") << "Requesting content that is not stored in miniAOD.\n";
   return pfSpecific().signalPiZeroCandidates_;
 }

const std::vector< reco::PFRecoTauChargedHadron > & Tau::signalTauChargedHadronCandidates ( ) 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 pfSpecific(), pfSpecific_, and pat::tau::TauPFSpecific::signalTauChargedHadronCandidates_.

                                                                                           {
   if(pfSpecific_.empty()) throw cms::Exception("Type Error") << "Requesting content that is not stored in miniAOD.\n";
   return pfSpecific().signalTauChargedHadronCandidates_;
 }

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

References embeddedSignalTracks_, i, edm::AtomicPtrCache< T >::isSet(), edm::RefVector< C, T, F >::reserve(), edm::AtomicPtrCache< T >::set(), reco::BaseTau::signalTracks(), signalTracks_, and signalTracksTransientRefVector_.

                                                    {
   if (embeddedSignalTracks_) {
     if (!signalTracksTransientRefVector_.isSet()) {
         std::unique_ptr<reco::TrackRefVector> trackRefVec{ new reco::TrackRefVector{} };
         trackRefVec->reserve(signalTracks_.size());
         for (unsigned int i = 0; i < signalTracks_.size(); i++) {
           trackRefVec->push_back(reco::TrackRef(&signalTracks_, i));
         }
     signalTracksTransientRefVector_.set(std::move(trackRefVec));
     }
     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 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'

Definition: Tau.cc:258

float signalTracksInvariantMass_

Definition: TauCaloSpecific.h:29

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

virtual

get the source candidate pointer with index i

Reimplemented from reco::LeafCandidate.

Definition at line 951 of file Tau.cc.

References ExistSignalCands(), i, pfSpecific(), pfSpecific_, pat::tau::TauPFSpecific::selectedSignalPFCands_, and signalCands().

                                                             {
   if (Tau::ExistSignalCands()) return Tau::signalCands()[i];
   else if(pfSpecific_.empty()) return reco::CandidatePtr();
   else return pfSpecific().selectedSignalPFCands_[i];
 }

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

References AlCaHLTBitMon_QueryRunRegistry::string, and tauID().

Referenced by tauID().

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

mergeVDriftHistosByStation.name

string name

Definition: mergeVDriftHistosByStation.py:77

AlCaHLTBitMon_QueryRunRegistry.string

string string

Definition: AlCaHLTBitMon_QueryRunRegistry.py:255

pat::Tau::tauID

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

Definition: Tau.cc:225

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