of constituents

pat::Jet::availableJECLevels

std::vector< pat::JetCorrFactors > jec_

Definition: Jet.h:531

void Jet::addTagInfo	(	const std::string &	label,
		const TagInfoFwdPtrCollection::value_type &	info
	)

sets a tagInfo with the given name from an edm::Ptr<T> to it. If the label ends with 'TagInfos', the 'TagInfos' is stripped out.

Definition at line 369 of file Jet.cc.

References customizeTrackingMonitorSeedNumber::idx, tagInfoLabels_, and tagInfosFwdPtr_.

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

                                                        {
     std::string::size_type idx = label.find("TagInfos");
     if (idx == std::string::npos) {
       tagInfoLabels_.push_back(label);
     } else {
         tagInfoLabels_.push_back(label.substr(0,idx));
     }
     tagInfosFwdPtr_.push_back(info);
 }

const reco::TrackRefVector & Jet::associatedTracks ( ) const

method to return a vector of refs to the tracks associated to this jet

Definition at line 388 of file Jet.cc.

References associatedTracks_.

Referenced by main().

                                                        {
   return associatedTracks_;
 }

const std::vector< std::string > Jet::availableJECLevels ( const int & set = 0 ) const

Definition at line 229 of file Jet.cc.

References jec_.

Referenced by PATJetCorrExtractor::operator()().

 {
   return set>=0 ? jec_.at(set).correctionLabels() : std::vector<std::string>();
 }

const std::vector<std::string> pat::Jet::availableJECLevels ( const std::string & set ) const

inline

Definition at line 116 of file Jet.h.

References availableJECLevels(), and jecSet().

Referenced by availableJECLevels().

116 { return availableJECLevels(jecSet(set)); };

const std::vector< std::string > availableJECLevels(const int &set=0) const

Definition: Jet.cc:229

pat::Jet::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: Jet.cc:213

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

-— methods for jet corrections -—

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

returns the labels of all available sets of jet energy corrections

Definition at line 221 of file Jet.cc.

References jec_.

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

float Jet::bDiscriminator ( const std::string & theLabel ) const

-— methods for accessing b-tagging info -—

get b discriminant from label name

Definition at line 305 of file Jet.cc.

References first, i, pairDiscriVector_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by AnalysisTasksAnalyzerBTag::analyze(), TtSemiLepJetComb::bTag(), bJetSelector::IsbTag(), TtHadLRJetCombObservables::operator()(), TtHadLRSignalSelObservables::CompareBdisc::operator()(), TtSemiLRJetCombObservables::operator()(), and TtSemiLRSignalSelObservables::CompareBdisc::operator()().

                                                         {
   float discriminator = -1000.;
   const std::string & theLabel = ((aLabel == "" || aLabel == "default")) ? "trackCountingHighEffBJetTags" : aLabel;
   for(unsigned int i=0; i!=pairDiscriVector_.size(); i++){
     if(pairDiscriVector_[i].first == theLabel){
       discriminator = pairDiscriVector_[i].second;
     }
   }
   return discriminator;
 }

void Jet::cacheCaloTowers ( ) const

private

cache calo towers

method to cache the constituents to allow "user-friendly" access

Definition at line 455 of file Jet.cc.

References edm::SortedCollection< T, SORT >::begin(), caloTowers_, caloTowersFwdPtr_, caloTowersTemp_, reco::CompositePtrCandidate::dau, reco::CompositePtrCandidate::daughterPtr(), embeddedCaloTowers_, edm::SortedCollection< T, SORT >::end(), edm::hlt::Exception, edm::Ptr< T >::get(), edm::Ptr< T >::id(), edm::Ptr< T >::key(), numberOfDaughters(), and edm::SortedCollection< T, SORT >::size().

Referenced by getCaloConstituents().

                                 {
   // Clear the cache
   // Here is where we've embedded constituents
   std::unique_ptr<std::vector<CaloTowerPtr>> caloTowersTemp{ new std::vector<CaloTowerPtr>{}};
   if ( embeddedCaloTowers_ ) {
     // Refactorized PAT access
     if ( caloTowersFwdPtr_.size() > 0 ) {
       caloTowersTemp->reserve(caloTowersFwdPtr_.size());
       for ( CaloTowerFwdPtrVector::const_iterator ibegin=caloTowersFwdPtr_.begin(),
           iend = caloTowersFwdPtr_.end(),
           icalo = ibegin;
         icalo != iend; ++icalo ) {
     caloTowersTemp->emplace_back( icalo->ptr()  );
       }
     }
     // Compatibility access
     else if ( caloTowers_.size() > 0 ) {
       caloTowersTemp->reserve(caloTowers_.size());
       for ( CaloTowerCollection::const_iterator ibegin=caloTowers_.begin(),
           iend = caloTowers_.end(),
           icalo = ibegin;
         icalo != iend; ++icalo ) {
     caloTowersTemp->emplace_back( &caloTowers_, icalo - ibegin  );
       }
     }
   }
   // Non-embedded access
   else {
     const auto nDaughters = numberOfDaughters();
     caloTowersTemp->reserve(nDaughters);    
     for ( unsigned fIndex = 0; fIndex < nDaughters; ++fIndex ) {
       Constituent const & dau = daughterPtr (fIndex);
       const CaloTower* caloTower = dynamic_cast <const CaloTower*> (dau.get());
       if (caloTower) {
     caloTowersTemp->emplace_back( dau.id(), caloTower,dau.key()  );
       }
       else {
     throw cms::Exception("Invalid Constituent") << "CaloJet constituent is not of CaloTower type";
       }
     }
   }
   caloTowersTemp_.set(std::move(caloTowersTemp));
 }

void Jet::cachePFCandidates ( ) const

private

method to cache the constituents to allow "user-friendly" access

Definition at line 500 of file Jet.cc.

References reco::CompositePtrCandidate::dau, reco::CompositePtrCandidate::daughterPtr(), embeddedPFCandidates_, edm::hlt::Exception, edm::Ptr< T >::get(), edm::Ptr< T >::id(), edm::Ptr< T >::key(), numberOfDaughters(), pfCandidates_, pfCandidatesFwdPtr_, pfCandidatesTemp_, and edm::AtomicPtrCache< T >::set().

Referenced by getPFConstituents().

                                   {
 
   std::unique_ptr<std::vector<reco::PFCandidatePtr>> pfCandidatesTemp{ new std::vector<reco::PFCandidatePtr>{}};
   // Here is where we've embedded constituents
   if ( embeddedPFCandidates_ ) {
     // Refactorized PAT access
     if ( pfCandidatesFwdPtr_.size() > 0 ) {
       pfCandidatesTemp->reserve(pfCandidatesFwdPtr_.size());
       for ( PFCandidateFwdPtrCollection::const_iterator ibegin=pfCandidatesFwdPtr_.begin(),
           iend = pfCandidatesFwdPtr_.end(),
           ipf = ibegin;
         ipf != iend; ++ipf ) {
     pfCandidatesTemp->emplace_back( ipf->ptr()  );
       }
     }
     // Compatibility access
     else if ( pfCandidates_.size() > 0 ) {
       pfCandidatesTemp->reserve(pfCandidates_.size());
       for ( reco::PFCandidateCollection::const_iterator ibegin=pfCandidates_.begin(),
           iend = pfCandidates_.end(),
           ipf = ibegin;
         ipf != iend; ++ipf ) {
     pfCandidatesTemp->emplace_back( &pfCandidates_, ipf - ibegin  );
       }
     }
   }
   // Non-embedded access
   else {
     const auto nDaughters = numberOfDaughters();
     pfCandidatesTemp->reserve(nDaughters);
     for ( unsigned fIndex = 0; fIndex < nDaughters; ++fIndex ) {
       Constituent const & dau = daughterPtr (fIndex);
       const reco::PFCandidate* pfCandidate = dynamic_cast <const reco::PFCandidate*> (dau.get());
       if (pfCandidate) {
     pfCandidatesTemp->emplace_back( dau.id(), pfCandidate,dau.key() );
       }
       else {
     throw cms::Exception("Invalid Constituent") << "PFJet constituent is not of PFCandidate type";
       }
     }
   }
   // Set the cache
   pfCandidatesTemp_.set(std::move(pfCandidatesTemp));
 }

const CaloSpecific& pat::Jet::caloSpecific ( ) const

inline

retrieve the calo specific part of the jet

Definition at line 241 of file Jet.h.

References specificCalo_.

Referenced by emEnergyFraction(), emEnergyInEB(), emEnergyInEE(), emEnergyInHF(), energyFractionHadronic(), hadEnergyInHB(), hadEnergyInHE(), hadEnergyInHF(), hadEnergyInHO(), maxEInEmTowers(), maxEInHadTowers(), and towersArea().

                                                {
     if (specificCalo_.empty()) throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a CaloJet.\n";
     return specificCalo_[0];
       }

CaloTowerFwdPtrVector const& pat::Jet::caloTowersFwdPtr ( ) const

inline

Access to bare FwdPtr collections.

Definition at line 464 of file Jet.h.

References caloTowersFwdPtr_.

464 { return caloTowersFwdPtr_;}

pat::Jet::caloTowersFwdPtr_

CaloTowerFwdPtrVector caloTowersFwdPtr_

Definition: Jet.h:510

float pat::Jet::chargedEmEnergy ( ) const

inline

chargedEmEnergy

Definition at line 597 of file Jet.h.

References edm::hlt::Exception.

Referenced by chargedEmEnergyFraction().

 {
   if(isPFJet()){ return pfSpecific().mChargedEmEnergy; }
   else if( isJPTJet() ){ return jptSpecific().mChargedEmEnergy;}
   else{ throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n"; }
 }

float pat::Jet::chargedEmEnergyFraction ( ) const

inline

chargedEmEnergyFraction (relative to uncorrected jet energy)

Definition at line 356 of file Jet.h.

References chargedEmEnergy(), reco::LeafCandidate::energy(), jecFactor(), and jecSetsAvailable().

Referenced by PFJetIDSelectionFunctor::firstDataCuts(), and main().

356 {return chargedEmEnergy()/((jecSetsAvailable() ? jecFactor(0) : 1.)*energy());}

virtual double energy() const GCC11_FINAL

energy

Definition: LeafCandidate.h:134

float jecFactor(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:236

pat::Jet::chargedEmEnergy

bool jecSetsAvailable() const

Definition: Jet.h:119

float chargedEmEnergy() const

chargedEmEnergy

Definition: Jet.h:597

float pat::Jet::chargedHadronEnergy ( ) const

inline

chargedHadronEnergy

Definition at line 583 of file Jet.h.

References edm::hlt::Exception, isJPTJet(), isPFJet(), jptSpecific(), reco::PFJet::Specific::mChargedHadronEnergy, reco::JPTJet::Specific::mChargedHadronEnergy, and pfSpecific().

Referenced by chargedHadronEnergyFraction().

 {
   if(isPFJet()){ return pfSpecific().mChargedHadronEnergy; }
   else if( isJPTJet() ){ return jptSpecific().mChargedHadronEnergy; }
   else{ throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n"; }
 }

float pat::Jet::chargedHadronEnergyFraction ( ) const

inline

chargedHadronEnergyFraction (relative to uncorrected jet energy)

Definition at line 352 of file Jet.h.

References chargedHadronEnergy(), reco::LeafCandidate::energy(), jecFactor(), and jecSetsAvailable().

Referenced by PFJetIDSelectionFunctor::firstDataCuts(), and main().

352 {return chargedHadronEnergy()/((jecSetsAvailable() ? jecFactor(0) : 1.)*energy());}

virtual double energy() const GCC11_FINAL

energy

Definition: LeafCandidate.h:134

float jecFactor(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:236

pat::Jet::chargedHadronEnergy

bool jecSetsAvailable() const

Definition: Jet.h:119

float chargedHadronEnergy() const

chargedHadronEnergy

Definition: Jet.h:583

int pat::Jet::chargedHadronMultiplicity ( ) const

inline

chargedHadronMultiplicity

Definition at line 383 of file Jet.h.

References reco::PFJet::Specific::mChargedHadronMultiplicity, and pfSpecific().

383 {return pfSpecific().mChargedHadronMultiplicity;}

reco::PFJet::Specific::mChargedHadronMultiplicity

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

int mChargedHadronMultiplicity

Definition: PFJet.h:60

float pat::Jet::chargedMuEnergy ( ) const

inline

chargedMuEnergy

Definition at line 397 of file Jet.h.

References reco::PFJet::Specific::mChargedMuEnergy, and pfSpecific().

Referenced by chargedMuEnergyFraction().

397 {return pfSpecific().mChargedMuEnergy;}

reco::PFJet::Specific::mChargedMuEnergy

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

float mChargedMuEnergy

Definition: PFJet.h:71

float pat::Jet::chargedMuEnergyFraction ( ) const

inline

chargedMuEnergyFraction

Definition at line 399 of file Jet.h.

References chargedMuEnergy(), reco::LeafCandidate::energy(), jecFactor(), and jecSetsAvailable().

399 {return chargedMuEnergy()/((jecSetsAvailable() ? jecFactor(0) : 1.)*energy());}

virtual double energy() const GCC11_FINAL

energy

Definition: LeafCandidate.h:134

float jecFactor(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:236

pat::Jet::chargedMuEnergy

bool jecSetsAvailable() const

Definition: Jet.h:119

float chargedMuEnergy() const

chargedMuEnergy

Definition: Jet.h:397

int pat::Jet::chargedMultiplicity ( ) const

inline

chargedMultiplicity

Definition at line 618 of file Jet.h.

References edm::hlt::Exception.

Referenced by PFJetIDSelectionFunctor::firstDataCuts().

 {
   if(isPFJet()){ return pfSpecific().mChargedMultiplicity; }
   else if( isJPTJet() ){ return jptSpecific().muonsInVertexInCalo.size()+jptSpecific().muonsInVertexOutCalo.size()+
                                 jptSpecific().pionsInVertexInCalo.size()+jptSpecific().pionsInVertexOutCalo.size()+
                                 jptSpecific().elecsInVertexInCalo.size()+jptSpecific().elecsInVertexOutCalo.size();}
   else{ throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n"; }
 }

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

inlinevirtual

required reimplementation of the Candidate's clone method

Reimplemented from reco::CompositePtrCandidate.

Definition at line 93 of file Jet.h.

References Jet().

93 { return new Jet(*this); }

pat::Jet::Jet

Jet()

default constructor

Definition: Jet.cc:12

Jet Jet::correctedJet	(	const std::string &	level,
		const std::string &	flavor = `"none"`,
		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 268 of file Jet.cc.

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

Referenced by correctedJet(), correctedP4(), StEvtSolution::getRecBottom(), TtHadEvtSolution::getRecHadb(), TtSemiEvtSolution::getRecHadb(), TtHadEvtSolution::getRecHadbbar(), TtHadEvtSolution::getRecHadj(), TtHadEvtSolution::getRecHadk(), TtHadEvtSolution::getRecHadp(), TtSemiEvtSolution::getRecHadp(), TtHadEvtSolution::getRecHadq(), TtSemiEvtSolution::getRecHadq(), TtDilepEvtSolution::getRecJetB(), TtDilepEvtSolution::getRecJetBbar(), TtSemiEvtSolution::getRecLepb(), StEvtSolution::getRecLight(), hitfit::JetTranslatorBase< AJet >::operator()(), and PFJetIDSelectionFunctor::operator()().

 {
   // 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 correctedJet(jec_[idx].jecLevel(level), jec_[idx].jecFlavor(flavor), 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";
 }

Jet Jet::correctedJet	(	const unsigned int &	level,
		const JetCorrFactors::Flavor &	flavor = `JetCorrFactors::NONE`,
		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 287 of file Jet.cc.

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

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

const LorentzVector& pat::Jet::correctedP4	(	const std::string &	level,
		const std::string &	flavor = `"none"`,
		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 146 of file Jet.h.

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

Referenced by PFJetMETcorrInputProducer_namespace::RawJetExtractorT< pat::Jet >::operator()(), CaloJetMETcorrInputProducer_namespace::RawJetExtractorT< pat::Jet >::operator()(), PATJetCorrExtractor::operator()(), SmearedJetProducer_namespace::RawJetExtractorT< pat::Jet >::operator()(), and JetIDSelectionFunctor::operator()().

146 { return correctedJet(level, flavor, set).p4(); };

reco::LeafCandidate::p4

virtual const LorentzVector & p4() const GCC11_FINAL

four-momentum Lorentz vector

Definition: LeafCandidate.h:123

pat::Jet::correctedJet

Jet correctedJet(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:268

testEve_cfg.level

tuple level

Definition: testEve_cfg.py:34

const LorentzVector& pat::Jet::correctedP4	(	const unsigned int &	level,
		const JetCorrFactors::Flavor &	flavor = `JetCorrFactors::NONE`,
		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 149 of file Jet.h.

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

149 { return correctedJet(level, flavor, set).p4(); };

reco::LeafCandidate::p4

virtual const LorentzVector & p4() const GCC11_FINAL

four-momentum Lorentz vector

Definition: LeafCandidate.h:123

pat::Jet::correctedJet

Jet correctedJet(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:268

testEve_cfg.level

tuple level

Definition: testEve_cfg.py:34

const JetCorrFactors* pat::Jet::corrFactors_ ( const std::string & set ) const

private

return the jet correction factors of a different set, for systematic studies

const JetCorrFactors* pat::Jet::corrFactors_ ( ) const

private

return the correction factor for this jet. Throws if they're not available.

JetCorrFactors::Flavor pat::Jet::currentJECFlavor ( ) const

inline

return flavour of the current step of jet energy corrections

Definition at line 131 of file Jet.h.

References currentJECFlavor_.

Referenced by correctedJet(), and initializeJEC().

131 { return currentJECFlavor_; };

pat::Jet::currentJECFlavor_

JetCorrFactors::Flavor currentJECFlavor_

Definition: Jet.h:539

void pat::Jet::currentJECFlavor ( const JetCorrFactors::Flavor & flavor )

inlineprivate

update the current JEC flavor; used by correctedJet

Definition at line 160 of file Jet.h.

References currentJECFlavor_.

160 { currentJECFlavor_=flavor; };

pat::Jet::currentJECFlavor_

JetCorrFactors::Flavor currentJECFlavor_

Definition: Jet.h:539

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

inline

return the name of the current step of jet energy corrections

Definition at line 129 of file Jet.h.

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

Referenced by correctedJet(), initializeJEC(), PFJetIDSelectionFunctor::operator()(), JetIDSelectionFunctor::operator()(), and PatJetAnalyzer::print().

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

AlCaHLTBitMon_QueryRunRegistry.string

string string

Definition: AlCaHLTBitMon_QueryRunRegistry.py:255

pat::Jet::currentJECLevel_

unsigned int currentJECLevel_

Definition: Jet.h:536

pat::Jet::currentJECLevel_

std::vector< pat::JetCorrFactors > jec_

Definition: Jet.h:531

pat::Jet::currentJECSet_

unsigned int currentJECSet_

Definition: Jet.h:534

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

inlineprivate

update the current JEC level; used by correctedJet

Definition at line 158 of file Jet.h.

References currentJECLevel_, and testEve_cfg::level.

158 { currentJECLevel_=level; };

unsigned int currentJECLevel_

Definition: Jet.h:536

testEve_cfg.level

tuple level

Definition: testEve_cfg.py:34

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

inline

returns the label of the current set of jet energy corrections

Definition at line 127 of file Jet.h.

References currentJECSet_, jec_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by correctedJet(), and initializeJEC().

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

AlCaHLTBitMon_QueryRunRegistry.string

string string

Definition: AlCaHLTBitMon_QueryRunRegistry.py:255

std::vector< pat::JetCorrFactors > jec_

Definition: Jet.h:531

pat::Jet::currentJECSet_

unsigned int currentJECSet_

Definition: Jet.h:534

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

inlineprivate

update the current JEC set; used by correctedJet

Definition at line 156 of file Jet.h.

References currentJECSet_.

156 { currentJECSet_=set; };

pat::Jet::currentJECSet_

unsigned int currentJECSet_

Definition: Jet.h:534

virtual const reco::Candidate* pat::Jet::daughter ( size_t i ) const

inlinevirtual

get a pointer to a Candididate constituent of the jet If using refactorized PAT, return that. (constituents size > 0) Else check the old version of PAT (embedded constituents size > 0) Else return the reco Jet number of constituents

Reimplemented from reco::CompositePtrCandidate.

Definition at line 417 of file Jet.h.

References caloTowers_, caloTowersFwdPtr_, reco::CompositePtrCandidate::daughter(), embeddedCaloTowers_, embeddedPFCandidates_, isCaloJet(), isJPTJet(), isPFJet(), pfCandidates_, pfCandidatesFwdPtr_, and edm::SortedCollection< T, SORT >::size().

                                                              {
     if (isCaloJet() || isJPTJet() ) {
       if ( embeddedCaloTowers_ ) {
         if ( caloTowersFwdPtr_.size() > 0 ) return caloTowersFwdPtr_[i].get();
         else if ( caloTowers_.size() > 0 ) return &caloTowers_[i];
         else return reco::Jet::daughter(i);
       }
     }
     if (isPFJet()) {
       if ( embeddedPFCandidates_ ) {
         if ( pfCandidatesFwdPtr_.size() > 0 ) return pfCandidatesFwdPtr_[i].get();
         else if ( pfCandidates_.size() > 0 ) return &pfCandidates_[i];
         else return reco::Jet::daughter(i);
       }
     }
     return reco::Jet::daughter(i);
       }

float pat::Jet::elecMultiplicity ( ) const

inline

chargedMultiplicity

Definition at line 334 of file Jet.h.

References reco::JPTJet::Specific::elecsInVertexInCalo, reco::JPTJet::Specific::elecsInVertexOutCalo, jptSpecific(), and edm::RefVector< C, T, F >::size().

334 {return jptSpecific().elecsInVertexInCalo.size()+jptSpecific().elecsInVertexOutCalo.size();}

reco::JPTJet::Specific::elecsInVertexInCalo

const JPTSpecific & jptSpecific() const

retrieve the jpt specific part of the jet

Definition: Jet.h:246

reco::TrackRefVector elecsInVertexInCalo

Definition: JPTJet.h:59

reco::JPTJet::Specific::elecsInVertexOutCalo

reco::TrackRefVector elecsInVertexOutCalo

Definition: JPTJet.h:60

edm::RefVector::size

size_type size() const

Size of the RefVector.

Definition: RefVector.h:89

const reco::TrackRefVector& pat::Jet::elecsInVertexInCalo ( ) const

inline

electrons fully contained in cone

Definition at line 326 of file Jet.h.

References reco::JPTJet::Specific::elecsInVertexInCalo, and jptSpecific().

326 {return jptSpecific().elecsInVertexInCalo; }

reco::JPTJet::Specific::elecsInVertexInCalo

const JPTSpecific & jptSpecific() const

retrieve the jpt specific part of the jet

Definition: Jet.h:246

reco::TrackRefVector elecsInVertexInCalo

Definition: JPTJet.h:59

const reco::TrackRefVector& pat::Jet::elecsInVertexOutCalo ( ) const

inline

electrons that curled out

Definition at line 328 of file Jet.h.

References reco::JPTJet::Specific::elecsInVertexOutCalo, and jptSpecific().

328 {return jptSpecific().elecsInVertexOutCalo;}

reco::JPTJet::Specific::elecsInVertexOutCalo

const JPTSpecific & jptSpecific() const

retrieve the jpt specific part of the jet

Definition: Jet.h:246

reco::TrackRefVector elecsInVertexOutCalo

Definition: JPTJet.h:60

const reco::TrackRefVector& pat::Jet::elecsOutVertexInCalo ( ) const

inline

electrons that curled in

Definition at line 330 of file Jet.h.

References reco::JPTJet::Specific::elecsOutVertexInCalo, and jptSpecific().

330 {return jptSpecific().elecsOutVertexInCalo;}

reco::JPTJet::Specific::elecsOutVertexInCalo

const JPTSpecific & jptSpecific() const

retrieve the jpt specific part of the jet

Definition: Jet.h:246

reco::TrackRefVector elecsOutVertexInCalo

Definition: JPTJet.h:61

float pat::Jet::electronEnergy ( ) const

inline

electronEnergy

Definition at line 366 of file Jet.h.

References reco::PFJet::Specific::mElectronEnergy, and pfSpecific().

Referenced by electronEnergyFraction().

366 {return pfSpecific().mElectronEnergy;}

reco::PFJet::Specific::mElectronEnergy

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

float mElectronEnergy

Definition: PFJet.h:55

float pat::Jet::electronEnergyFraction ( ) const

inline

electronEnergyFraction (relative to corrected jet energy)

Definition at line 368 of file Jet.h.

References electronEnergy(), reco::LeafCandidate::energy(), jecFactor(), and jecSetsAvailable().

368 {return electronEnergy()/((jecSetsAvailable() ? jecFactor(0) : 1.)*energy());}

virtual double energy() const GCC11_FINAL

energy

Definition: LeafCandidate.h:134

float jecFactor(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:236

bool jecSetsAvailable() const

Definition: Jet.h:119

pat::Jet::electronEnergy

float electronEnergy() const

electronEnergy

Definition: Jet.h:366

int pat::Jet::electronMultiplicity ( ) const

inline

electronMultiplicity

Definition at line 389 of file Jet.h.

References reco::PFJet::Specific::mElectronMultiplicity, and pfSpecific().

389 {return pfSpecific().mElectronMultiplicity;}

reco::PFJet::Specific::mElectronMultiplicity

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

int mElectronMultiplicity

Definition: PFJet.h:63

float pat::Jet::emEnergyFraction ( ) const

inline

returns the jet electromagnetic energy fraction

Definition at line 280 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mEnergyFractionEm.

Referenced by PatZjetsJetAnalyzer::analyze(), main(), and JetIDSelectionFunctor::operator()().

280 {return caloSpecific().mEnergyFractionEm;}

reco::CaloJet::Specific::mEnergyFractionEm

float mEnergyFractionEm

Em energy fraction.

Definition: CaloJet.h:73

reco::CaloJet::Specific::mEmEnergyInEB

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

float pat::Jet::emEnergyInEB ( ) const

inline

returns the jet electromagnetic energy in EB

Definition at line 290 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mEmEnergyInEB.

290 {return caloSpecific().mEmEnergyInEB;}

float mEmEnergyInEB

Em energy in EB.

Definition: CaloJet.h:65

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

float pat::Jet::emEnergyInEE ( ) const

inline

returns the jet electromagnetic energy in EE

Definition at line 292 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mEmEnergyInEE.

292 {return caloSpecific().mEmEnergyInEE;}

reco::CaloJet::Specific::mEmEnergyInEE

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

float mEmEnergyInEE

Em energy in EE.

Definition: CaloJet.h:67

float pat::Jet::emEnergyInHF ( ) const

inline

returns the jet electromagnetic energy extracted from HF

Definition at line 294 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mEmEnergyInHF.

294 {return caloSpecific().mEmEnergyInHF;}

reco::CaloJet::Specific::mEmEnergyInHF

float mEmEnergyInHF

Em energy in HF.

Definition: CaloJet.h:69

reco::CaloJet::Specific::mEnergyFractionHadronic

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

float pat::Jet::energyFractionHadronic ( ) const

inline

returns the jet hadronic energy fraction

Definition at line 278 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mEnergyFractionHadronic.

278 {return caloSpecific().mEnergyFractionHadronic;}

float mEnergyFractionHadronic

Hadronic energy fraction.

Definition: CaloJet.h:71

pat::PATObject< reco::Jet >::genParticle

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

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

return the matched generated jet

Definition at line 180 of file Jet.cc.

References genJet_, genJetFwdRef_, genJetRef_, edm::FwdRef< C, T, F >::get(), and edm::RefVector< C, T, F >::size().

Referenced by main(), and SmearedJetProducer_namespace::GenJetMatcherT< pat::Jet >::operator()().

                                      {
   if (genJet_.size()) return  &(genJet_.front());
   else if ( genJetRef_.size() ) return genJetRef_[0].get();
   else return genJetFwdRef_.get();
 }

edm::FwdRef<reco::GenJetCollection> const& pat::Jet::genJetFwdRef ( ) const

inline

Definition at line 466 of file Jet.h.

References genJetFwdRef_.

466 { return genJetFwdRef_; }

pat::Jet::genJetFwdRef_

edm::FwdRef< reco::GenJetCollection > genJetFwdRef_

Definition: Jet.h:523

const reco::GenParticle* pat::Jet::genParton ( ) const

inline

-— methods for MC matching -—

return the matched generated parton

Definition at line 98 of file Jet.h.

References pat::PATObject< reco::Jet >::genParticle().

98 { return genParticle(); }

const reco::GenParticle * genParticle(size_t idx=0) const

Definition: PATObject.h:236

CaloTowerPtr Jet::getCaloConstituent ( unsigned fIndex ) const

convert generic constituent to specific type

============= CaloJet methods ============

get specific constituent of the CaloJet. if the caloTowers were embedded, this reference is transient only and must not be persisted

Definition at line 98 of file Jet.cc.

References caloTowers_, caloTowersFwdPtr_, reco::CompositePtrCandidate::dau, reco::CompositePtrCandidate::daughterPtr(), embeddedCaloTowers_, edm::hlt::Exception, edm::Ptr< T >::get(), edm::Ptr< T >::id(), edm::Ptr< T >::key(), and edm::SortedCollection< T, SORT >::size().

Referenced by PatZjetsJetAnalyzer::analyze().

                                                            {
     if (embeddedCaloTowers_) {
       // Refactorized PAT access
       if ( caloTowersFwdPtr_.size() > 0 ) {
     return (fIndex < caloTowersFwdPtr_.size() ?
         caloTowersFwdPtr_[fIndex].ptr() : CaloTowerPtr());
       }
       // Compatibility PAT access
       else {
     if ( caloTowers_.size() > 0 ) {
       return (fIndex < caloTowers_.size() ?
           CaloTowerPtr(&caloTowers_, fIndex) : CaloTowerPtr());
 
     }
       }
     }
     // Non-embedded access
     else {
       Constituent dau = daughterPtr (fIndex);
       const CaloTower* caloTower = dynamic_cast <const CaloTower*> (dau.get());
       if (caloTower != 0) {
     return CaloTowerPtr(dau.id(), caloTower, dau.key() );
       }
       else {
     throw cms::Exception("Invalid Constituent") << "CaloJet constituent is not of CaloTower type";
       }
 
     }
 
     return CaloTowerPtr ();
 }

std::vector< CaloTowerPtr > const & Jet::getCaloConstituents ( ) const

get the constituents of the CaloJet. If the caloTowers were embedded, these reference are transient only and must not be persisted

Definition at line 132 of file Jet.cc.

References cacheCaloTowers(), caloTowers_, caloTowersTemp_, and edm::SortedCollection< T, SORT >::size().

Referenced by PatZjetsJetAnalyzer::analyze(), and JetIDSelectionFunctor::operator()().

                                                                 {
   if ( !caloTowersTemp_.isSet() || caloTowers_.size() > 0 ) cacheCaloTowers();
   return *caloTowersTemp_;
 }

const std::vector< std::pair< std::string, float > > & Jet::getPairDiscri ( ) const

get vector of paire labelname-disciValue

============= BTag information methods ============

Definition at line 300 of file Jet.cc.

References pairDiscriVector_.

                                                                        {
    return pairDiscriVector_;
 }

reco::PFCandidatePtr Jet::getPFConstituent ( unsigned fIndex ) const

convert generic constituent to specific type

============= PFJet methods ============

get specific constituent of the CaloJet. if the caloTowers were embedded, this reference is transient only and must not be persisted

Definition at line 140 of file Jet.cc.

References reco::CompositePtrCandidate::dau, reco::CompositePtrCandidate::daughterPtr(), embeddedPFCandidates_, edm::hlt::Exception, edm::Ptr< T >::get(), edm::Ptr< T >::id(), edm::Ptr< T >::key(), pfCandidates_, and pfCandidatesFwdPtr_.

                                                                {
     if (embeddedPFCandidates_) {
       // Refactorized PAT access
       if ( pfCandidatesFwdPtr_.size() > 0 ) {
     return (fIndex < pfCandidatesFwdPtr_.size() ?
         pfCandidatesFwdPtr_[fIndex].ptr() : reco::PFCandidatePtr());
       }
       // Compatibility PAT access
       else {
     if ( pfCandidates_.size() > 0 ) {
       return (fIndex < pfCandidates_.size() ?
           reco::PFCandidatePtr(&pfCandidates_, fIndex) : reco::PFCandidatePtr());
 
     }
       }
     }
     // Non-embedded access
     else {
       Constituent dau = daughterPtr (fIndex);
       const reco::PFCandidate* pfCandidate = dynamic_cast <const reco::PFCandidate*> (dau.get());
       if (pfCandidate) {
     return reco::PFCandidatePtr(dau.id(), pfCandidate, dau.key() );
       }
       else {
     throw cms::Exception("Invalid Constituent") << "PFJet constituent is not of PFCandidate type";
       }
 
     }
 
     return reco::PFCandidatePtr ();
 }

std::vector< reco::PFCandidatePtr > const & Jet::getPFConstituents ( ) const

get the constituents of the CaloJet. If the caloTowers were embedded, these reference are transient only and must not be persisted

Definition at line 172 of file Jet.cc.

References cachePFCandidates(), edm::AtomicPtrCache< T >::isSet(), pfCandidates_, and pfCandidatesTemp_.

                                                                     {
   if ( !pfCandidatesTemp_.isSet() || pfCandidates_.size() > 0 ) cachePFCandidates();
   return *pfCandidatesTemp_;
 }

float pat::Jet::hadEnergyInHB ( ) const

inline

returns the jet hadronic energy in HB

Definition at line 282 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mHadEnergyInHB.

282 {return caloSpecific().mHadEnergyInHB;}

reco::CaloJet::Specific::mHadEnergyInHB

float mHadEnergyInHB

Hadronic energy in HB.

Definition: CaloJet.h:59

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

float pat::Jet::hadEnergyInHE ( ) const

inline

returns the jet hadronic energy in HE

Definition at line 286 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mHadEnergyInHE.

286 {return caloSpecific().mHadEnergyInHE;}

reco::CaloJet::Specific::mHadEnergyInHE

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

float mHadEnergyInHE

Hadronic energy in HE.

Definition: CaloJet.h:63

float pat::Jet::hadEnergyInHF ( ) const

inline

returns the jet hadronic energy in HF

Definition at line 288 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mHadEnergyInHF.

288 {return caloSpecific().mHadEnergyInHF;}

reco::CaloJet::Specific::mHadEnergyInHF

float mHadEnergyInHF

Hadronic energy in HF.

Definition: CaloJet.h:61

reco::CaloJet::Specific::mHadEnergyInHO

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

float pat::Jet::hadEnergyInHO ( ) const

inline

returns the jet hadronic energy in HO

Definition at line 284 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mHadEnergyInHO.

284 {return caloSpecific().mHadEnergyInHO;}

float mHadEnergyInHO

Hadronic nergy fraction in HO.

Definition: CaloJet.h:57

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

int Jet::hadronFlavour ( ) const

return the hadron-based flavour of the jet

Definition at line 192 of file Jet.cc.

References reco::JetFlavourInfo::getHadronFlavour(), and jetFlavourInfo_.

                              {
   return jetFlavourInfo_.getHadronFlavour();
 }

bool pat::Jet::hasTagInfo ( const std::string label ) const

inline

check to see if the given tag info is nonzero

Definition at line 174 of file Jet.h.

References tagInfo().

174 { return tagInfo(label) != 0; }

diffTwoXMLs.label

list label

Definition: diffTwoXMLs.py:42

pat::Jet::tagInfo

const reco::BaseTagInfo * tagInfo(const std::string &label) const

Definition: Jet.cc:316

float pat::Jet::HFEMEnergy ( ) const

inline

HFEMEnergy.

Definition at line 378 of file Jet.h.

References reco::PFJet::Specific::mHFEMEnergy, and pfSpecific().

Referenced by HFEMEnergyFraction().

378 {return pfSpecific().mHFEMEnergy;}

reco::PFJet::Specific::mHFEMEnergy

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

float mHFEMEnergy

Definition: PFJet.h:58

float pat::Jet::HFEMEnergyFraction ( ) const

inline

HFEMEnergyFraction (relative to corrected jet energy)

Definition at line 380 of file Jet.h.

References reco::LeafCandidate::energy(), HFEMEnergy(), jecFactor(), and jecSetsAvailable().

380 {return HFEMEnergy()/((jecSetsAvailable() ? jecFactor(0) : 1.)*energy());}

virtual double energy() const GCC11_FINAL

energy

Definition: LeafCandidate.h:134

float jecFactor(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:236

bool jecSetsAvailable() const

Definition: Jet.h:119

pat::Jet::HFEMEnergy

float HFEMEnergy() const

HFEMEnergy.

Definition: Jet.h:378

int pat::Jet::HFEMMultiplicity ( ) const

inline

HFEMMultiplicity.

Definition at line 394 of file Jet.h.

References reco::PFJet::Specific::mHFEMMultiplicity, and pfSpecific().

394 {return pfSpecific().mHFEMMultiplicity;}

reco::PFJet::Specific::mHFEMMultiplicity

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

int mHFEMMultiplicity

Definition: PFJet.h:66

float pat::Jet::HFHadronEnergy ( ) const

inline

HFHadronEnergy.

Definition at line 374 of file Jet.h.

References reco::PFJet::Specific::mHFHadronEnergy, and pfSpecific().

Referenced by PFJetIDSelectionFunctor::firstDataCuts(), and HFHadronEnergyFraction().

374 {return pfSpecific().mHFHadronEnergy;}

reco::PFJet::Specific::mHFHadronEnergy

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

float mHFHadronEnergy

Definition: PFJet.h:57

float pat::Jet::HFHadronEnergyFraction ( ) const

inline

HFHadronEnergyFraction (relative to corrected jet energy)

Definition at line 376 of file Jet.h.

References reco::LeafCandidate::energy(), HFHadronEnergy(), jecFactor(), and jecSetsAvailable().

376 {return HFHadronEnergy()/((jecSetsAvailable() ? jecFactor(0) : 1.)*energy());}

virtual double energy() const GCC11_FINAL

energy

Definition: LeafCandidate.h:134

float jecFactor(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:236

bool jecSetsAvailable() const

Definition: Jet.h:119

pat::Jet::HFHadronEnergy

float HFHadronEnergy() const

HFHadronEnergy.

Definition: Jet.h:374

int pat::Jet::HFHadronMultiplicity ( ) const

inline

HFHadronMultiplicity.

Definition at line 392 of file Jet.h.

References reco::PFJet::Specific::mHFHadronMultiplicity, and pfSpecific().

392 {return pfSpecific().mHFHadronMultiplicity;}

reco::PFJet::Specific::mHFHadronMultiplicity

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

int mHFHadronMultiplicity

Definition: PFJet.h:65

void Jet::initializeJEC	(	unsigned int	level,
		const JetCorrFactors::Flavor &	flavor = `JetCorrFactors::NONE`,
		unsigned int	set = `0`
	)

private

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

============= Jet Energy Correction methods ============

Definition at line 204 of file Jet.cc.

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

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

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

bool pat::Jet::isBasicJet ( ) const

inline

check to see if the jet is no more than a reco::BasicJet

Definition at line 239 of file Jet.h.

References isCaloJet(), isJPTJet(), and isPFJet().

Referenced by PFJetIDSelectionFunctor::firstDataCuts().

239 { return !(isCaloJet() || isPFJet() || isJPTJet()); }

pat::Jet::isCaloJet

bool isCaloJet() const

check to see if the jet is a reco::CaloJet

Definition: Jet.h:233

pat::Jet::isPFJet

bool isPFJet() const

check to see if the jet is a reco::PFJet

Definition: Jet.h:237

pat::Jet::isJPTJet

bool isJPTJet() const

check to see if the jet is a reco::JPTJet

Definition: Jet.h:235

bool pat::Jet::isCaloJet ( ) const

inline

check to see if the jet is a reco::CaloJet

Definition at line 233 of file Jet.h.

References isJPTJet(), and specificCalo_.

Referenced by hitfit::JetTranslatorBase< AJet >::CheckEta(), daughter(), isBasicJet(), numberOfDaughters(), CaloJetMETcorrInputProducer_namespace::InputTypeCheckerT< pat::Jet >::operator()(), hitfit::JetTranslatorBase< AJet >::operator()(), JetIDSelectionFunctor::operator()(), and pat::PATJetProducer::produce().

233 { return !specificCalo_.empty() && !isJPTJet(); }

pat::Jet::specificCalo_

std::vector< CaloSpecific > specificCalo_

Definition: Jet.h:556

pat::Jet::isJPTJet

bool isJPTJet() const

check to see if the jet is a reco::JPTJet

Definition: Jet.h:235

bool pat::Jet::isJPTJet ( ) const

inline

check to see if the jet is a reco::JPTJet

Definition at line 235 of file Jet.h.

References specificJPT_.

Referenced by chargedHadronEnergy(), daughter(), isBasicJet(), isCaloJet(), numberOfDaughters(), JetIDSelectionFunctor::operator()(), and pat::PATJetProducer::produce().

235 { return !specificJPT_.empty(); }

pat::Jet::specificJPT_

std::vector< JPTSpecific > specificJPT_

Definition: Jet.h:557

bool pat::Jet::isPFJet ( ) const

inline

check to see if the jet is a reco::PFJet

Definition at line 237 of file Jet.h.

References specificPF_.

Referenced by chargedHadronEnergy(), hitfit::JetTranslatorBase< AJet >::CheckEta(), daughter(), PFJetIDSelectionFunctor::firstDataCuts(), isBasicJet(), numberOfDaughters(), PFJetMETcorrInputProducer_namespace::InputTypeCheckerT< pat::Jet, PATJetCorrExtractor >::operator()(), SmearedJetProducer_namespace::JetResolutionExtractorT< pat::Jet >::operator()(), hitfit::JetTranslatorBase< AJet >::operator()(), and pat::PATJetProducer::produce().

237 { return !specificPF_.empty(); }

pat::Jet::specificPF_

std::vector< PFSpecific > specificPF_

Definition: Jet.h:558

float Jet::jecFactor	(	const std::string &	level,
		const std::string &	flavor = `"none"`,
		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 236 of file Jet.cc.

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

Referenced by chargedEmEnergyFraction(), chargedHadronEnergyFraction(), chargedMuEnergyFraction(), TtFullHadKinFitter::KinFit::corJet(), correctedJet(), electronEnergyFraction(), HFEMEnergyFraction(), HFHadronEnergyFraction(), main(), muonEnergyFraction(), neutralEmEnergyFraction(), neutralHadronEnergyFraction(), and photonEnergyFraction().

 {
   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), jec_[idx].jecFlavor(flavor), 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 Jet::jecFactor	(	const unsigned int &	level,
		const JetCorrFactors::Flavor &	flavor = `JetCorrFactors::NONE`,
		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 254 of file Jet.cc.

References currentJECFlavor_, 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, flavor)/jec_.at(currentJECSet_).correction(currentJECLevel_, currentJECFlavor_);
 }

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

private

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 213 of file Jet.cc.

References jec_.

Referenced by availableJECLevels(), and jecSetAvailable().

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

bool pat::Jet::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 122 of file Jet.h.

References jecSet().

Referenced by jecFactor().

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

pat::Jet::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: Jet.cc:213

bool pat::Jet::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 125 of file Jet.h.

References jec_.

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

Referenced by chargedEmEnergyFraction(), chargedHadronEnergyFraction(), chargedMuEnergyFraction(), electronEnergyFraction(), HFEMEnergyFraction(), HFHadronEnergyFraction(), jecFactor(), muonEnergyFraction(), neutralEmEnergyFraction(), neutralHadronEnergyFraction(), PFJetMETcorrInputProducer_namespace::RawJetExtractorT< pat::Jet >::operator()(), CaloJetMETcorrInputProducer_namespace::RawJetExtractorT< pat::Jet >::operator()(), SmearedJetProducer_namespace::RawJetExtractorT< pat::Jet >::operator()(), PFJetIDSelectionFunctor::operator()(), and photonEnergyFraction().

std::vector< pat::JetCorrFactors > jec_

Definition: Jet.h:531

bool pat::Jet::jecSetsAvailable ( ) const

inline

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

Definition at line 119 of file Jet.h.

References jec_.

119 { return !jec_.empty(); }

reco::CaloJet::Specific::mMaxEInEmTowers

std::vector< pat::JetCorrFactors > jec_

Definition: Jet.h:531

float Jet::jetCharge ( ) const

method to return the JetCharge computed when creating the Jet

Definition at line 383 of file Jet.cc.

References jetCharge_.

Referenced by setJetCharge().

                            {
   return jetCharge_;
 }

const reco::JetFlavourInfo & Jet::jetFlavourInfo ( ) const

return the JetFlavourInfo of the jet

Definition at line 197 of file Jet.cc.

References jetFlavourInfo_.

Referenced by setJetFlavourInfo().

                                                      {
   return jetFlavourInfo_;
 }

reco::JetID const& pat::Jet::jetID ( ) const

inline

accessing Jet ID information

Definition at line 460 of file Jet.h.

References jetID_.

Referenced by main(), and JetIDSelectionFunctor::operator()().

460 { return jetID_;}

pat::Jet::jetID_

reco::JetID jetID_

Definition: Jet.h:561

const JPTSpecific& pat::Jet::jptSpecific ( ) const

inline

retrieve the jpt specific part of the jet

Definition at line 246 of file Jet.h.

References specificJPT_.

Referenced by chargedHadronEnergy(), elecMultiplicity(), elecsInVertexInCalo(), elecsInVertexOutCalo(), elecsOutVertexInCalo(), muonsInVertexInCalo(), muonsInVertexOutCalo(), muonsOutVertexInCalo(), pionsInVertexInCalo(), pionsInVertexOutCalo(), pionsOutVertexInCalo(), and zspCorrection().

                                              {
     if (specificJPT_.empty()) throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet.\n";
     return specificJPT_[0];
       }

float pat::Jet::maxEInEmTowers ( ) const

inline

returns the maximum energy deposited in ECAL towers

Definition at line 274 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mMaxEInEmTowers.

274 {return caloSpecific().mMaxEInEmTowers;}

float mMaxEInEmTowers

Maximum energy in EM towers.

Definition: CaloJet.h:53

reco::CaloJet::Specific::mMaxEInHadTowers

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

float pat::Jet::maxEInHadTowers ( ) const

inline

returns the maximum energy deposited in HCAL towers

Definition at line 276 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mMaxEInHadTowers.

276 {return caloSpecific().mMaxEInHadTowers;}

float mMaxEInHadTowers

Maximum energy in HCAL towers.

Definition: CaloJet.h:55

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

float pat::Jet::muonEnergy ( ) const

inline

muonEnergy

Definition at line 370 of file Jet.h.

References reco::PFJet::Specific::mMuonEnergy, and pfSpecific().

Referenced by muonEnergyFraction().

370 {return pfSpecific().mMuonEnergy;}

reco::PFJet::Specific::mMuonEnergy

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

float mMuonEnergy

Definition: PFJet.h:56

float pat::Jet::muonEnergyFraction ( ) const

inline

muonEnergyFraction (relative to corrected jet energy)

Definition at line 372 of file Jet.h.

References reco::LeafCandidate::energy(), jecFactor(), jecSetsAvailable(), and muonEnergy().

372 {return muonEnergy()/((jecSetsAvailable() ? jecFactor(0) : 1.)*energy());}

virtual double energy() const GCC11_FINAL

energy

Definition: LeafCandidate.h:134

float jecFactor(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:236

pat::Jet::muonEnergy

float muonEnergy() const

muonEnergy

Definition: Jet.h:370

bool jecSetsAvailable() const

Definition: Jet.h:119

int pat::Jet::muonMultiplicity ( ) const

inline

muonMultiplicity

Definition at line 611 of file Jet.h.

References edm::hlt::Exception.

 {
   if(isPFJet()){ return pfSpecific().mMuonMultiplicity; }
   else if( isJPTJet() ){ return jptSpecific().muonsInVertexInCalo.size()+jptSpecific().muonsInVertexOutCalo.size();}
   else{ throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n"; }
 }

const reco::TrackRefVector& pat::Jet::muonsInVertexInCalo ( ) const

inline

muons fully contained in cone

Definition at line 320 of file Jet.h.

References jptSpecific(), and reco::JPTJet::Specific::muonsInVertexInCalo.

320 {return jptSpecific().muonsInVertexInCalo; }

reco::JPTJet::Specific::muonsInVertexInCalo

const JPTSpecific & jptSpecific() const

retrieve the jpt specific part of the jet

Definition: Jet.h:246

reco::TrackRefVector muonsInVertexInCalo

Definition: JPTJet.h:56

const reco::TrackRefVector& pat::Jet::muonsInVertexOutCalo ( ) const

inline

muons that curled out

Definition at line 322 of file Jet.h.

References jptSpecific(), and reco::JPTJet::Specific::muonsInVertexOutCalo.

322 {return jptSpecific().muonsInVertexOutCalo;}

reco::JPTJet::Specific::muonsInVertexOutCalo

reco::TrackRefVector muonsInVertexOutCalo

Definition: JPTJet.h:57

const JPTSpecific & jptSpecific() const

retrieve the jpt specific part of the jet

Definition: Jet.h:246

const reco::TrackRefVector& pat::Jet::muonsOutVertexInCalo ( ) const

inline

muons that curled in

Definition at line 324 of file Jet.h.

References jptSpecific(), and reco::JPTJet::Specific::muonsOutVertexInCalo.

324 {return jptSpecific().muonsOutVertexInCalo;}

reco::JPTJet::Specific::muonsOutVertexInCalo

const JPTSpecific & jptSpecific() const

retrieve the jpt specific part of the jet

Definition: Jet.h:246

reco::TrackRefVector muonsOutVertexInCalo

Definition: JPTJet.h:58

int pat::Jet::n60 ( ) const

inline

returns the number of constituents carrying a 60% of the total Jet energy*/

Definition at line 300 of file Jet.h.

References reco::Jet::nCarrying().

300 {return nCarrying (0.6);}

reco::Jet::nCarrying

int nCarrying(float fFraction) const

return # of constituent carrying fraction of energy

Definition: Jet.cc:291

int pat::Jet::n90 ( ) const

inline

returns the number of constituents carrying a 90% of the total Jet energy*/

Definition at line 298 of file Jet.h.

References reco::Jet::nCarrying().

298 {return nCarrying (0.9);}

reco::Jet::nCarrying

int nCarrying(float fFraction) const

return # of constituent carrying fraction of energy

Definition: Jet.cc:291

float pat::Jet::neutralEmEnergy ( ) const

inline

neutralEmEnergy

Definition at line 604 of file Jet.h.

References edm::hlt::Exception.

Referenced by neutralEmEnergyFraction().

 {
   if(isPFJet()){ return pfSpecific().mNeutralEmEnergy; }
   else if( isJPTJet() ){ return jptSpecific().mNeutralEmEnergy;}
   else{ throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n"; }
 }

float pat::Jet::neutralEmEnergyFraction ( ) const

inline

neutralEmEnergyFraction (relative to uncorrected jet energy)

Definition at line 358 of file Jet.h.

References reco::LeafCandidate::energy(), jecFactor(), jecSetsAvailable(), and neutralEmEnergy().

Referenced by PFJetIDSelectionFunctor::firstDataCuts(), and main().

358 {return neutralEmEnergy()/((jecSetsAvailable() ? jecFactor(0) : 1.)*energy());}

virtual double energy() const GCC11_FINAL

energy

Definition: LeafCandidate.h:134

float jecFactor(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:236

pat::Jet::neutralEmEnergy

bool jecSetsAvailable() const

Definition: Jet.h:119

float neutralEmEnergy() const

neutralEmEnergy

Definition: Jet.h:604

float pat::Jet::neutralHadronEnergy ( ) const

inline

neutralHadronEnergy

Definition at line 590 of file Jet.h.

References edm::hlt::Exception.

Referenced by PFJetIDSelectionFunctor::firstDataCuts(), and neutralHadronEnergyFraction().

 {
   if(isPFJet()){ return pfSpecific().mNeutralHadronEnergy; }
   else if( isJPTJet() ){ return jptSpecific().mNeutralHadronEnergy; }
   else{ throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n"; }
 }

float pat::Jet::neutralHadronEnergyFraction ( ) const

inline

neutralHadronEnergyFraction (relative to uncorrected jet energy)

Definition at line 354 of file Jet.h.

References reco::LeafCandidate::energy(), jecFactor(), jecSetsAvailable(), and neutralHadronEnergy().

Referenced by main().

354 {return neutralHadronEnergy()/((jecSetsAvailable() ? jecFactor(0) : 1.)*energy());}

virtual double energy() const GCC11_FINAL

energy

Definition: LeafCandidate.h:134

float jecFactor(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:236

pat::Jet::neutralHadronEnergy

bool jecSetsAvailable() const

Definition: Jet.h:119

float neutralHadronEnergy() const

neutralHadronEnergy

Definition: Jet.h:590

int pat::Jet::neutralHadronMultiplicity ( ) const

inline

neutralHadronMultiplicity

Definition at line 385 of file Jet.h.

References reco::PFJet::Specific::mNeutralHadronMultiplicity, and pfSpecific().

385 {return pfSpecific().mNeutralHadronMultiplicity;}

reco::PFJet::Specific::mNeutralHadronMultiplicity

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

int mNeutralHadronMultiplicity

Definition: PFJet.h:61

int pat::Jet::neutralMultiplicity ( ) const

inline

neutralMultiplicity

Definition at line 402 of file Jet.h.

References reco::PFJet::Specific::mNeutralMultiplicity, and pfSpecific().

402 {return pfSpecific().mNeutralMultiplicity;}

reco::PFJet::Specific::mNeutralMultiplicity

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

int mNeutralMultiplicity

Definition: PFJet.h:74

virtual size_t pat::Jet::numberOfDaughters ( ) const

inlinevirtual

Return number of daughters: If using refactorized PAT, return that. (constituents size > 0) Else check the old version of PAT (embedded constituents size > 0) Else return the reco Jet number of constituents

Reimplemented from reco::CompositePtrCandidate.

Definition at line 441 of file Jet.h.

References caloTowers_, caloTowersFwdPtr_, embeddedCaloTowers_, embeddedPFCandidates_, isCaloJet(), isJPTJet(), isPFJet(), reco::CompositePtrCandidate::numberOfDaughters(), pfCandidates_, pfCandidatesFwdPtr_, and edm::SortedCollection< T, SORT >::size().

Referenced by cacheCaloTowers(), cachePFCandidates(), and PFJetIDSelectionFunctor::firstDataCuts().

                                                {
     if (isCaloJet() || isJPTJet()) {
       if ( embeddedCaloTowers_ ) {
         if ( caloTowersFwdPtr_.size() > 0 ) return caloTowersFwdPtr_.size();
         else if ( caloTowers_.size() > 0 ) return caloTowers_.size();
         else return reco::Jet::numberOfDaughters();
       }
     }
     if (isPFJet()) {
       if ( embeddedPFCandidates_ ) {
         if ( pfCandidatesFwdPtr_.size() > 0 ) return pfCandidatesFwdPtr_.size();
         else if ( pfCandidates_.size() > 0 ) return pfCandidates_.size();
         else return reco::Jet::numberOfDaughters();
       }
     }
     return reco::Jet::numberOfDaughters();
       }

int Jet::partonFlavour ( ) const

return the parton-based flavour of the jet

Definition at line 187 of file Jet.cc.

References reco::JetFlavourInfo::getPartonFlavour(), and jetFlavourInfo_.

Referenced by AnalysisTasksAnalyzerBTag::analyze(), and TtDilepLRSignalSelObservables::operator()().

                              {
   return jetFlavourInfo_.getPartonFlavour();
 }

reco::PFCandidateFwdPtrVector const& pat::Jet::pfCandidatesFwdPtr ( ) const

inline

Definition at line 465 of file Jet.h.

References pfCandidatesFwdPtr_.

465 { return pfCandidatesFwdPtr_; }

pat::Jet::pfCandidatesFwdPtr_

reco::PFCandidateFwdPtrVector pfCandidatesFwdPtr_

Definition: Jet.h:516

const PFSpecific& pat::Jet::pfSpecific ( ) const

inline

retrieve the pf specific part of the jet

Definition at line 251 of file Jet.h.

References specificPF_.

Referenced by chargedHadronEnergy(), chargedHadronMultiplicity(), chargedMuEnergy(), electronEnergy(), electronMultiplicity(), HFEMEnergy(), HFEMMultiplicity(), HFHadronEnergy(), HFHadronMultiplicity(), muonEnergy(), neutralHadronMultiplicity(), neutralMultiplicity(), SmearedJetProducer_namespace::JetResolutionExtractorT< pat::Jet >::operator()(), photonEnergy(), and photonMultiplicity().

                                            {
     if (specificPF_.empty()) throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a PFJet.\n";
     return specificPF_[0];
       }

float pat::Jet::photonEnergy ( ) const

inline

photonEnergy

Definition at line 362 of file Jet.h.

References reco::PFJet::Specific::mPhotonEnergy, and pfSpecific().

Referenced by photonEnergyFraction().

362 {return pfSpecific().mPhotonEnergy;}

reco::PFJet::Specific::mPhotonEnergy

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

float mPhotonEnergy

Definition: PFJet.h:54

float pat::Jet::photonEnergyFraction ( ) const

inline

photonEnergyFraction (relative to corrected jet energy)

Definition at line 364 of file Jet.h.

References reco::LeafCandidate::energy(), jecFactor(), jecSetsAvailable(), and photonEnergy().

364 {return photonEnergy()/((jecSetsAvailable() ? jecFactor(0) : 1.)*energy());}

pat::Jet::photonEnergy

float photonEnergy() const

photonEnergy

Definition: Jet.h:362

virtual double energy() const GCC11_FINAL

energy

Definition: LeafCandidate.h:134

float jecFactor(const std::string &level, const std::string &flavor="none", const std::string &set="") const

Definition: Jet.cc:236

bool jecSetsAvailable() const

Definition: Jet.h:119

int pat::Jet::photonMultiplicity ( ) const

inline

photonMultiplicity

Definition at line 387 of file Jet.h.

References reco::PFJet::Specific::mPhotonMultiplicity, and pfSpecific().

387 {return pfSpecific().mPhotonMultiplicity;}

reco::PFJet::Specific::mPhotonMultiplicity

const PFSpecific & pfSpecific() const

retrieve the pf specific part of the jet

Definition: Jet.h:251

int mPhotonMultiplicity

Definition: PFJet.h:62

const reco::TrackRefVector& pat::Jet::pionsInVertexInCalo ( ) const

inline

pions fully contained in cone

Definition at line 314 of file Jet.h.

References jptSpecific(), and reco::JPTJet::Specific::pionsInVertexInCalo.

314 {return jptSpecific().pionsInVertexInCalo; }

reco::JPTJet::Specific::pionsInVertexInCalo

const JPTSpecific & jptSpecific() const

retrieve the jpt specific part of the jet

Definition: Jet.h:246

reco::TrackRefVector pionsInVertexInCalo

Definition: JPTJet.h:53

const reco::TrackRefVector& pat::Jet::pionsInVertexOutCalo ( ) const

inline

pions that curled out

Definition at line 316 of file Jet.h.

References jptSpecific(), and reco::JPTJet::Specific::pionsInVertexOutCalo.

316 {return jptSpecific().pionsInVertexOutCalo;}

reco::JPTJet::Specific::pionsInVertexOutCalo

const JPTSpecific & jptSpecific() const

retrieve the jpt specific part of the jet

Definition: Jet.h:246

reco::TrackRefVector pionsInVertexOutCalo

Definition: JPTJet.h:54

const reco::TrackRefVector& pat::Jet::pionsOutVertexInCalo ( ) const

inline

pions that curled in

Definition at line 318 of file Jet.h.

References jptSpecific(), and reco::JPTJet::Specific::pionsOutVertexInCalo.

318 {return jptSpecific().pionsOutVertexInCalo;}

reco::JPTJet::Specific::pionsOutVertexInCalo

const JPTSpecific & jptSpecific() const

retrieve the jpt specific part of the jet

Definition: Jet.h:246

reco::TrackRefVector pionsOutVertexInCalo

Definition: JPTJet.h:55

void Jet::setAssociatedTracks ( const reco::TrackRefVector & tracks )

method to set the vector of refs to the tracks associated to this jet

Definition at line 393 of file Jet.cc.

References associatedTracks_, and testEve_cfg::tracks.

Referenced by pat::PATJetSlimmer::produce(), and pat::PATJetProducer::produce().

                                                               {
     associatedTracks_ = tracks;
 }

void pat::Jet::setCaloSpecific ( const CaloSpecific & newCaloSpecific )

inline

set the calo specific part of the jet

Definition at line 256 of file Jet.h.

References specificCalo_.

                                                                 {
     if (specificCalo_.empty()) throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a CaloJet.\n";
     specificCalo_[0] = newCaloSpecific;
       }

void Jet::setCaloTowers ( const CaloTowerFwdPtrCollection & caloTowers )

method to store the CaloJet constituents internally

Definition at line 398 of file Jet.cc.

References caloTowersFwdPtr_, caloTowersTemp_, and embeddedCaloTowers_.

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

                                                                     {
   caloTowersFwdPtr_.reserve(caloTowers.size());
   for(auto const& tower : caloTowers) {
     caloTowersFwdPtr_.push_back( tower );
   }
   embeddedCaloTowers_ = true;
   caloTowersTemp_.reset();
 }

void Jet::setGenJetRef ( const edm::FwdRef< reco::GenJetCollection > & gj )

method to set the matched generated jet reference, embedding if requested

Definition at line 420 of file Jet.cc.

References genJetFwdRef_.

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

 {
   genJetFwdRef_ = gj;
 }

void pat::Jet::setGenParton	(	const reco::GenParticleRef &	gp,
		bool	embed = `false`
	)

inline

method to set the matched parton

Definition at line 216 of file Jet.h.

References embed, and pat::PATObject< reco::Jet >::setGenParticleRef().

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

216 { setGenParticleRef(gp, embed); }

pat::PATObject< reco::Jet >::setGenParticleRef

void setGenParticleRef(const reco::GenParticleRef &ref, bool embed=false)

Set the generator level particle reference.

embed

#define embed

Definition: AMPTWrapper.h:178

void Jet::setHadronFlavour ( int hadronFl )

method to set the hadron-based flavour of the jet

Definition at line 433 of file Jet.cc.

References jetFlavourInfo_, and reco::JetFlavourInfo::setHadronFlavour().

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

                                        {
   jetFlavourInfo_.setHadronFlavour(hadronFl);
 }

void Jet::setJetCharge ( float jetCharge )

method to set the jet charge

Definition at line 448 of file Jet.cc.

References jetCharge(), and jetCharge_.

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

                                       {
   jetCharge_ = jetCharge;
 }

void Jet::setJetFlavourInfo ( const reco::JetFlavourInfo & jetFlavourInfo )

method to set the JetFlavourInfo of the jet

Definition at line 438 of file Jet.cc.

References jetFlavourInfo(), and jetFlavourInfo_.

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

                                                                      {
   jetFlavourInfo_ = jetFlavourInfo;
 }

void pat::Jet::setJetID ( reco::JetID const & id )

inline

methods for jet ID

Definition at line 228 of file Jet.h.

References jetID_.

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

228 { jetID_ = id; }

pat::Jet::jetID_

reco::JetID jetID_

Definition: Jet.h:561

void pat::Jet::setJPTSpecific ( const JPTSpecific & newJPTSpecific )

inline

set the jpt specific part of the jet

Definition at line 261 of file Jet.h.

References specificJPT_.

                                                              {
     if (specificJPT_.empty()) throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet.\n";
     specificJPT_[0] = newJPTSpecific;
       }

void Jet::setPartonFlavour ( int partonFl )

method to set the parton-based flavour of the jet

Definition at line 428 of file Jet.cc.

References jetFlavourInfo_, and reco::JetFlavourInfo::setPartonFlavour().

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

                                        {
   jetFlavourInfo_.setPartonFlavour(partonFl);
 }

void Jet::setPFCandidates ( const PFCandidateFwdPtrCollection & pfCandidates )

method to store the PFCandidate constituents internally

method to store the CaloJet constituents internally

Definition at line 409 of file Jet.cc.

References embeddedPFCandidates_, pfCandidatesFwdPtr_, pfCandidatesTemp_, and edm::AtomicPtrCache< T >::reset().

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

                                                                           {
   pfCandidatesFwdPtr_.reserve(pfCandidates.size());
   for(auto const& cand : pfCandidates) {
     pfCandidatesFwdPtr_.push_back(cand);
   }
   embeddedPFCandidates_ = true;
   pfCandidatesTemp_.reset();
 }

void pat::Jet::setPFSpecific ( const PFSpecific & newPFSpecific )

inline

set the pf specific part of the jet

Definition at line 266 of file Jet.h.

References specificPF_.

                                                           {
     if (specificPF_.empty()) throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a PFJet.\n";
     specificPF_[0] = newPFSpecific;
       }

const reco::BaseTagInfo * Jet::tagInfo ( const std::string & label ) const

get a tagInfo with the given name, or NULL if none is found. You should omit the 'TagInfos' part from the label

Definition at line 316 of file Jet.cc.

References spr::find(), diffTwoXMLs::label, edm::OwnVector< T, P >::size(), tagInfoLabels_, tagInfos_, and tagInfosFwdPtr_.

Referenced by hasTagInfo(), tagInfoSecondaryVertex(), tagInfoSoftLepton(), and tagInfoTrackIP().

                                                                  {
     std::vector<std::string>::const_iterator it = std::find(tagInfoLabels_.begin(), tagInfoLabels_.end(), label);
     if (it != tagInfoLabels_.end()) {
       if ( tagInfosFwdPtr_.size() > 0 ) return tagInfosFwdPtr_[it - tagInfoLabels_.begin()].get();
       else if ( tagInfos_.size() > 0 )  return & tagInfos_[it - tagInfoLabels_.begin()];
       return 0;
     }
     return 0;
 }

template<typename T >

const T * Jet::tagInfoByType ( ) const

private

Definition at line 328 of file Jet.cc.

References i, n, edm::OwnVector< T, P >::size(), tagInfos_, and tagInfosFwdPtr_.

                                     {
   // First check the factorized PAT version
     for (size_t i = 0, n = tagInfosFwdPtr_.size(); i < n; ++i) {
       TagInfoFwdPtrCollection::value_type const & val = tagInfosFwdPtr_[i];
       reco::BaseTagInfo const * baseTagInfo = val.get();
       if ( typeid(*baseTagInfo) == typeid(T) ) {
     return static_cast<const T *>( baseTagInfo );
       }
     }
     // Then check compatibility version
     for (size_t i = 0, n = tagInfos_.size(); i < n; ++i) {
       edm::OwnVector<reco::BaseTagInfo>::value_type const & val = tagInfos_[i];
       reco::BaseTagInfo const * baseTagInfo = &val;
       if ( typeid(*baseTagInfo) == typeid(T) ) {
     return static_cast<const T *>( baseTagInfo );
       }
     }
     return 0;
 }

const reco::SecondaryVertexTagInfo * Jet::tagInfoSecondaryVertex ( const std::string & label = "" ) const

get a tagInfo with the given name and type or NULL if none is found. If the label is empty or not specified, it returns the first tagInfo of that type (if any one exists) you should omit the 'TagInfos' part from the label

Definition at line 363 of file Jet.cc.

References tagInfo().

                                                         {
     return (label.empty() ? tagInfoByType<reco::SecondaryVertexTagInfo>()
                           : dynamic_cast<const reco::SecondaryVertexTagInfo *>(tagInfo(label)) );
 }

TagInfoFwdPtrCollection const& pat::Jet::tagInfosFwdPtr ( ) const

inline

Definition at line 467 of file Jet.h.

References tagInfosFwdPtr_.

467 { return tagInfosFwdPtr_; }

pat::Jet::tagInfosFwdPtr_

TagInfoFwdPtrCollection tagInfosFwdPtr_

Definition: Jet.h:546

const reco::SoftLeptonTagInfo * Jet::tagInfoSoftLepton ( const std::string & label = "" ) const

get a tagInfo with the given name and type or NULL if none is found. If the label is empty or not specified, it returns the first tagInfo of that type (if any one exists) you should omit the 'TagInfos' part from the label

Definition at line 357 of file Jet.cc.

References tagInfo().

                                                    {
     return (label.empty() ? tagInfoByType<reco::SoftLeptonTagInfo>()
                           : dynamic_cast<const reco::SoftLeptonTagInfo *>(tagInfo(label)) );
 }

const reco::TrackIPTagInfo * Jet::tagInfoTrackIP ( const std::string & label = "" ) const

get a tagInfo with the given name and type or NULL if none is found. If the label is empty or not specified, it returns the first tagInfo of that type (if any one exists) you should omit the 'TagInfos' part from the label

Definition at line 351 of file Jet.cc.

References tagInfo().

                                                 {
     return (label.empty() ? tagInfoByType<reco::TrackIPTagInfo>()
                           : dynamic_cast<const reco::TrackIPTagInfo *>(tagInfo(label)) );
 }

float pat::Jet::towersArea ( ) const

inline

returns area of contributing towers

Definition at line 296 of file Jet.h.

References caloSpecific(), and reco::CaloJet::Specific::mTowersArea.

296 {return caloSpecific().mTowersArea;}

reco::CaloJet::Specific::mTowersArea

float mTowersArea

Area of contributing CaloTowers.

Definition: CaloJet.h:75

const CaloSpecific & caloSpecific() const

retrieve the calo specific part of the jet

Definition: Jet.h:241

void Jet::tryImportSpecific ( const reco::Jet & source )

private

constructor helper that tries to import the specific info from the source jet

Definition at line 68 of file Jet.cc.

References edm::RefToBase< T >::get(), reco::JPTJet::getCaloJetRef(), reco::JPTJet::getSpecific(), reco::CaloJet::getSpecific(), edm::RefToBase< T >::isAvailable(), edm::RefToBase< T >::isNonnull(), source, specificCalo_, specificJPT_, and specificPF_.

Referenced by Jet().

 {
   const std::type_info & type = typeid(source);
   if( type == typeid(reco::CaloJet) ){
     specificCalo_.push_back( (static_cast<const reco::CaloJet&>(source)).getSpecific() );
   } else if( type == typeid(reco::JPTJet) ){
     reco::JPTJet const & jptJet = static_cast<reco::JPTJet const &>(source);
     specificJPT_.push_back( jptJet.getSpecific() );
     reco::CaloJet const * caloJet = 0;
     if ( jptJet.getCaloJetRef().isNonnull() && jptJet.getCaloJetRef().isAvailable() ) {
       caloJet = dynamic_cast<reco::CaloJet const *>( jptJet.getCaloJetRef().get() );
     }
     if ( caloJet != 0 ) {
       specificCalo_.push_back( caloJet->getSpecific() );
     }
     else {
       edm::LogWarning("OptionalProductNotFound") << " in pat::Jet, Attempted to add Calo Specifics to JPT Jets, but failed."
                          << " Jet ID for JPT Jets will not be available for you." << std::endl;
     }
   } else if( type == typeid(reco::PFJet) ){
     specificPF_.push_back( (static_cast<const reco::PFJet&>(source)).getSpecific() );
   }
 }

void pat::Jet::updateFwdCaloTowerFwdPtr	(	unsigned int	index,
		const edm::Ptr< CaloTower > &	updateFwd
	)

inline

Update bare FwdPtr and FwdRef "forward" pointers while keeping the "back" pointers the same (i.e. the ref "forwarding")

Definition at line 471 of file Jet.h.

References caloTowersFwdPtr_, and edm::hlt::Exception.

                                                                                               {
     if ( index < caloTowersFwdPtr_.size() ) {
       caloTowersFwdPtr_[index] = CaloTowerFwdPtrVector::value_type( updateFwd, caloTowersFwdPtr_[index].backPtr() );
     } else {
       throw cms::Exception("OutOfRange") << "Index " << index << " is out of range" << std::endl;
     }
       }

void pat::Jet::updateFwdGenJetFwdRef ( edm::Ref< reco::GenJetCollection > updateRef )

inline

Definition at line 496 of file Jet.h.

References edm::FwdRef< C, T, F >::backRef(), and genJetFwdRef_.

                                                                            {
     genJetFwdRef_ = edm::FwdRef<reco::GenJetCollection>( updateRef, genJetFwdRef_.backRef() );
       }

void pat::Jet::updateFwdPFCandidateFwdPtr	(	unsigned int	index,
		const edm::Ptr< reco::PFCandidate > &	updateFwd
	)

inline

Definition at line 479 of file Jet.h.

References edm::hlt::Exception, and pfCandidatesFwdPtr_.

                                                                                                       {
     if ( index < pfCandidatesFwdPtr_.size() ) {
       pfCandidatesFwdPtr_[index] = reco::PFCandidateFwdPtrVector::value_type( updateFwd, pfCandidatesFwdPtr_[index].backPtr() );
     } else {
       throw cms::Exception("OutOfRange") << "Index " << index << " is out of range" << std::endl;
     }
       }

void pat::Jet::updateFwdTagInfoFwdPtr	(	unsigned int	index,
		const edm::Ptr< reco::BaseTagInfo > &	updateFwd
	)

inline

Definition at line 488 of file Jet.h.

References edm::hlt::Exception, and tagInfosFwdPtr_.

                                                                                                   {
     if ( index < tagInfosFwdPtr_.size() ) {
       tagInfosFwdPtr_[index] = TagInfoFwdPtrCollection::value_type( updateFwd, tagInfosFwdPtr_[index].backPtr() );
     } else {
       throw cms::Exception("OutOfRange") << "Index " << index << " is out of range" << std::endl;
     }
       }

const float& pat::Jet::zspCorrection ( ) const

inline

zero suppression correction

Definition at line 332 of file Jet.h.

References jptSpecific(), and reco::JPTJet::Specific::mZSPCor.

332 {return jptSpecific().mZSPCor;}