#include <RecoTauConstructor.h>

Public Types
enum	ParticleType { kChargedHadron, kGamma, kNeutralHadron, kAll }

enum	Region { kSignal, kIsolation }

Public Member Functions
void	addPFCand (Region region, ParticleType type, const CandidatePtr &ptr, bool skipAddToP4=false)
	Append a PFCandidateRef/Ptr to a given collection. More...

template<typename InputIterator >
void	addPFCands (Region region, ParticleType type, const InputIterator &begin, const InputIterator &end)

void	addPiZero (Region region, const RecoTauPiZero &piZero)
	Add a PiZero to the given collection. More...

template<typename InputIterator >
void	addPiZeros (Region region, const InputIterator &begin, const InputIterator &end)
	Add a list of pizeros to the input collection. More...

void	addTauChargedHadron (Region region, const PFRecoTauChargedHadron &chargedHadron)
	Add a ChargedHadron to the given collection. More...

template<typename InputIterator >
void	addTauChargedHadrons (Region region, const InputIterator &begin, const InputIterator &end)
	Add a list of charged hadrons to the input collection. More...

std::auto_ptr< reco::PFTau >	get (bool setupLeadingCandidates=true)

const reco::Candidate::LorentzVector &	p4 () const

	RecoTauConstructor (const JetBaseRef &jetRef, const edm::Handle< edm::View< reco::Candidate > > &pfCands, bool copyGammasFromPiZeros=false, const StringObjectFunction< reco::PFTau > *signalConeSize=0, double minAbsPhotonSumPt_insideSignalCone=2.5, double minRelPhotonSumPt_insideSignalCone=0., double minAbsPhotonSumPt_outsideSignalCone=1.e+9, double minRelPhotonSumPt_outsideSignalCone=1.e+9)
	Constructor with PFCandidate Handle. More...

void	reserve (Region region, ParticleType type, size_t size)
	Reserve a set amount of space for a given RefVector. More...

void	reservePiZero (Region region, size_t size)
	Reserve a set amount of space for the PiZeros. More...

void	reserveTauChargedHadron (Region region, size_t size)
	Reserve a set amount of space for the ChargedHadrons. More...

template<typename T >
void	setleadCand (const T &cand)
	Set leading PF candidate. More...

template<typename T >
void	setleadChargedHadrCand (const T &cand)
	Set leading PFChargedHadron candidate. More...

template<typename T >
void	setleadNeutralCand (const T &cand)
	Set leading PFGamma candidate. More...

Private Types
typedef std::pair< Region, ParticleType >	CollectionKey

typedef std::map< CollectionKey, std::vector< CandidatePtr > * >	CollectionMap

typedef std::map< CollectionKey, SortedListPtr >	SortedCollectionMap

typedef boost::shared_ptr< std::vector< CandidatePtr > >	SortedListPtr

Private Member Functions
CandidatePtr	convertToPtr (const PFCandidatePtr &pfPtr) const

CandidatePtr	convertToPtr (const CandidatePtr &candPtr) const

std::vector< CandidatePtr > *	getCollection (Region region, ParticleType type)

SortedListPtr	getSortedCollection (Region region, ParticleType type)

void	sortAndCopyIntoTau ()

Private Attributes
CollectionMap	collections_

bool	copyGammas_

double	minAbsPhotonSumPt_insideSignalCone_

double	minAbsPhotonSumPt_outsideSignalCone_

double	minRelPhotonSumPt_insideSignalCone_

double	minRelPhotonSumPt_outsideSignalCone_

reco::Candidate::LorentzVector	p4_

const edm::Handle< edm::View< reco::Candidate > > &	pfCands_

const StringObjectFunction< reco::PFTau > *	signalConeSize_

SortedCollectionMap	sortedCollections_

std::auto_ptr< reco::PFTau >	tau_

Detailed Description

Definition at line 40 of file RecoTauConstructor.h.

Member Typedef Documentation

typedef std::pair<Region, ParticleType> reco::tau::RecoTauConstructor::CollectionKey

private

Definition at line 133 of file RecoTauConstructor.h.

typedef std::map<CollectionKey, std::vector<CandidatePtr>*> reco::tau::RecoTauConstructor::CollectionMap

private

Definition at line 134 of file RecoTauConstructor.h.

typedef std::map<CollectionKey, SortedListPtr> reco::tau::RecoTauConstructor::SortedCollectionMap

private

Definition at line 136 of file RecoTauConstructor.h.

typedef boost::shared_ptr<std::vector<CandidatePtr> > reco::tau::RecoTauConstructor::SortedListPtr

private

Definition at line 135 of file RecoTauConstructor.h.

Member Enumeration Documentation

enum reco::tau::RecoTauConstructor::ParticleType

Enumerator
kChargedHadron
kGamma
kNeutralHadron
kAll

Definition at line 47 of file RecoTauConstructor.h.

                       {
       kChargedHadron,
       kGamma,
       kNeutralHadron,
       kAll
     };

enum reco::tau::RecoTauConstructor::Region

Enumerator
kSignal
kIsolation

Definition at line 42 of file RecoTauConstructor.h.

                 {
       kSignal,
       kIsolation
     };

Constructor & Destructor Documentation

reco::tau::RecoTauConstructor::RecoTauConstructor	(	const JetBaseRef &	jetRef,
		const edm::Handle< edm::View< reco::Candidate > > &	pfCands,
		bool	copyGammasFromPiZeros = `false`,
		const StringObjectFunction< reco::PFTau > *	signalConeSize = `0`,
		double	minAbsPhotonSumPt_insideSignalCone = `2.5`,
		double	minRelPhotonSumPt_insideSignalCone = `0.`,
		double	minAbsPhotonSumPt_outsideSignalCone = `1.e+9`,
		double	minRelPhotonSumPt_outsideSignalCone = `1.e+9`
	)

Constructor with PFCandidate Handle.

Definition at line 12 of file RecoTauConstructor.cc.

References collections_, copyGammas_, kAll, kChargedHadron, kGamma, kIsolation, kNeutralHadron, kSignal, RecoPFTauTag_cff::PFTau, sortedCollections_, and tau_.

   : signalConeSize_(signalConeSize),
     minAbsPhotonSumPt_insideSignalCone_(minAbsPhotonSumPt_insideSignalCone),
     minRelPhotonSumPt_insideSignalCone_(minRelPhotonSumPt_insideSignalCone),
     minAbsPhotonSumPt_outsideSignalCone_(minAbsPhotonSumPt_outsideSignalCone),
     minRelPhotonSumPt_outsideSignalCone_(minRelPhotonSumPt_outsideSignalCone),
     pfCands_(pfCands)
 {
   // Initialize tau
   tau_.reset(new PFTau());
 
   copyGammas_ = copyGammasFromPiZeros;
   // Initialize our Accessors
   collections_[std::make_pair(kSignal, kChargedHadron)] =
       &tau_->selectedSignalChargedHadrCands_;
   collections_[std::make_pair(kSignal, kGamma)] =
       &tau_->selectedSignalGammaCands_;
   collections_[std::make_pair(kSignal, kNeutralHadron)] =
       &tau_->selectedSignalNeutrHadrCands_;
   collections_[std::make_pair(kSignal, kAll)] =
       &tau_->selectedSignalCands_;
 
   collections_[std::make_pair(kIsolation, kChargedHadron)] =
       &tau_->selectedIsolationChargedHadrCands_;
   collections_[std::make_pair(kIsolation, kGamma)] =
       &tau_->selectedIsolationGammaCands_;
   collections_[std::make_pair(kIsolation, kNeutralHadron)] =
       &tau_->selectedIsolationNeutrHadrCands_;
   collections_[std::make_pair(kIsolation, kAll)] =
       &tau_->selectedIsolationCands_;
 
   // Build our temporary sorted collections, since you can't use stl sorts on
   // RefVectors
   for(auto const& colkey : collections_) {
     // Build an empty list for each collection
     sortedCollections_[colkey.first] = SortedListPtr(
         new SortedListPtr::element_type);
   }
 
   tau_->setjetRef(jet);
 }

Member Function Documentation

void reco::tau::RecoTauConstructor::addPFCand	(	Region	region,
		ParticleType	type,
		const CandidatePtr &	ptr,
		bool	skipAddToP4 = `false`
	)

Append a PFCandidateRef/Ptr to a given collection.

Definition at line 58 of file RecoTauConstructor.cc.

References copyGammas_, getSortedCollection(), kAll, kGamma, kSignal, LogDebug, and p4_.

Referenced by addPFCands(), addTauChargedHadron(), and setleadCand().

                                                                                                               {
   LogDebug("TauConstructorAddPFCand") << " region = " << region << ", type = " << type << ": Pt = " << ptr->pt() << ", eta = " << ptr->eta() << ", phi = " << ptr->phi();
   if ( region == kSignal ) {
     // Keep track of the four vector of the signal vector products added so far.
     // If a photon add it if we are not using PiZeros to build the gammas
     if ( ((type != kGamma) || !copyGammas_) && !skipAddToP4 ) {
       LogDebug("TauConstructorAddPFCand") << "--> adding PFCand to tauP4." ;
       p4_ += ptr->p4();
     }
   }
   getSortedCollection(region, type)->push_back(ptr);
   // Add to global collection
   getSortedCollection(region, kAll)->push_back(ptr);
 }

template<typename InputIterator >

void reco::tau::RecoTauConstructor::addPFCands	(	Region	region,
		ParticleType	type,
		const InputIterator &	begin,
		const InputIterator &	end
	)

inline

Definition at line 91 of file RecoTauConstructor.h.

References addPFCand(), addTauChargedHadron(), muons2muons_cfi::chargedHadron, convertToPtr(), end, and reserveTauChargedHadron().

Referenced by addPiZero(), reco::tau::RecoTauBuilderCombinatoricPlugin::operator()(), and reco::tau::RecoTauBuilderConePlugin::operator()().

     {
       for(InputIterator iter = begin; iter != end; ++iter) {
     addPFCand(region, type, convertToPtr(*iter));
       }
     }

void reco::tau::RecoTauConstructor::addPiZero	(	Region	region,
		const RecoTauPiZero &	piZero
	)

Add a PiZero to the given collection.

Definition at line 186 of file RecoTauConstructor.cc.

References addPFCands(), copyGammas_, reco::CompositePtrCandidate::daughterPtrVector(), reco::LeafCandidate::eta(), kGamma, kIsolation, kSignal, LogDebug, reco::LeafCandidate::p4(), p4_, reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), and tau_.

Referenced by addPiZeros(), and addTauChargedHadrons().

 {
   LogDebug("TauConstructorAddPi0") << " region = " << region << ": Pt = " << piZero.pt() << ", eta = " << piZero.eta() << ", phi = " << piZero.phi();
   if ( region == kSignal ) {
     tau_->signalPiZeroCandidatesRestricted().push_back(piZero);
     // Copy the daughter gammas into the gamma collection if desired
     if ( copyGammas_ ) {
       // If we are using the pizeros to build the gammas, make sure we update
       // the four vector correctly.
       p4_ += piZero.p4();
       addPFCands(kSignal, kGamma, piZero.daughterPtrVector().begin(), 
           piZero.daughterPtrVector().end());
     }
   } else {
     tau_->isolationPiZeroCandidatesRestricted().push_back(piZero);
     if ( copyGammas_ ) {
       addPFCands(kIsolation, kGamma, piZero.daughterPtrVector().begin(),
           piZero.daughterPtrVector().end());
     }
   }
 }

template<typename InputIterator >

void reco::tau::RecoTauConstructor::addPiZeros	(	Region	region,
		const InputIterator &	begin,
		const InputIterator &	end
	)

inline

Add a list of pizeros to the input collection.

Definition at line 119 of file RecoTauConstructor.h.

References addPiZero(), and end.

Referenced by reco::tau::RecoTauBuilderCombinatoricPlugin::operator()(), and reco::tau::RecoTauBuilderConePlugin::operator()().

     {
       for ( InputIterator iter = begin; iter != end; ++iter ) {
     addPiZero(region, *iter);
       }
     }

void reco::tau::RecoTauConstructor::addTauChargedHadron	(	Region	region,
		const PFRecoTauChargedHadron &	chargedHadron
	)

Add a ChargedHadron to the given collection.

Definition at line 122 of file RecoTauConstructor.cc.

References funct::abs(), addPFCand(), muons2muons_cfi::chargedHadron, g4TestGeometry_cfi::checkOverlap(), convertToPtr(), copyGammas_, reco::LeafCandidate::eta(), reco::PFRecoTauChargedHadron::getChargedPFCandidate(), reco::PFRecoTauChargedHadron::getNeutralPFCandidates(), getSortedCollection(), edm::Ptr< T >::isNonnull(), kChargedHadron, kGamma, kIsolation, kNeutralHadron, kSignal, LogDebug, reco::PFRecoTauChargedHadron::neutralPFCandidates_, reco::LeafCandidate::p4(), p4_, reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), reco::tau::setChargedHadronP4(), and tau_.

Referenced by addPFCands(), and addTauChargedHadrons().

 {
   LogDebug("TauConstructorAddChH") << " region = " << region << ": Pt = " << chargedHadron.pt() << ", eta = " << chargedHadron.eta() << ", phi = " << chargedHadron.phi();
   // CV: need to make sure that PFGammas merged with ChargedHadrons are not part of PiZeros
   const std::vector<CandidatePtr>& neutrals = chargedHadron.getNeutralPFCandidates();
   std::vector<CandidatePtr> neutrals_cleaned;
   for ( std::vector<CandidatePtr>::const_iterator neutral = neutrals.begin();
     neutral != neutrals.end(); ++neutral ) {
     LogDebug("TauConstructorAddChH") << "neutral = " << neutral->id() << ":" << neutral->key();
     bool isUnique = true;
     if ( copyGammas_ ) checkOverlap(*neutral, *getSortedCollection(kSignal, kGamma), isUnique);
     else checkOverlap(*neutral, tau_->signalPiZeroCandidatesRestricted(), isUnique);
     if ( region == kIsolation ) {
       if ( copyGammas_ ) checkOverlap(*neutral, *getSortedCollection(kIsolation, kGamma), isUnique);
       else checkOverlap(*neutral, tau_->isolationPiZeroCandidatesRestricted(), isUnique);      
     }
     LogDebug("TauConstructorAddChH") << "--> isUnique = " << isUnique;
     if ( isUnique ) neutrals_cleaned.push_back(*neutral);
   }
   PFRecoTauChargedHadron chargedHadron_cleaned = chargedHadron;
   if ( neutrals_cleaned.size() != neutrals.size() ) {
     chargedHadron_cleaned.neutralPFCandidates_ = neutrals_cleaned;
     setChargedHadronP4(chargedHadron_cleaned);
   }
   if ( region == kSignal ) {
     tau_->signalTauChargedHadronCandidatesRestricted().push_back(chargedHadron_cleaned);
     p4_ += chargedHadron_cleaned.p4();
     if ( chargedHadron_cleaned.getChargedPFCandidate().isNonnull() ) {
       addPFCand(kSignal, kChargedHadron, convertToPtr(chargedHadron_cleaned.getChargedPFCandidate()), true);
     }
     const std::vector<CandidatePtr>& neutrals = chargedHadron_cleaned.getNeutralPFCandidates();
     for ( std::vector<CandidatePtr>::const_iterator neutral = neutrals.begin();
       neutral != neutrals.end(); ++neutral ) {
       if      ( std::abs((*neutral)->pdgId()) == 22 ) addPFCand(kSignal, kGamma, convertToPtr(*neutral), true);
       else if ( std::abs((*neutral)->pdgId()) == 130 ) addPFCand(kSignal, kNeutralHadron, convertToPtr(*neutral), true);
     };
   } else {
     tau_->isolationTauChargedHadronCandidatesRestricted().push_back(chargedHadron_cleaned);
     if ( chargedHadron_cleaned.getChargedPFCandidate().isNonnull() ) {
       if      ( std::abs(chargedHadron_cleaned.getChargedPFCandidate()->pdgId()) == 211  ) addPFCand(kIsolation, kChargedHadron, convertToPtr(chargedHadron_cleaned.getChargedPFCandidate()));
       else if ( std::abs(chargedHadron_cleaned.getChargedPFCandidate()->pdgId()) == 130 ) addPFCand(kIsolation, kNeutralHadron, convertToPtr(chargedHadron_cleaned.getChargedPFCandidate()));
     }
     const std::vector<CandidatePtr>& neutrals = chargedHadron_cleaned.getNeutralPFCandidates();
     for ( std::vector<CandidatePtr>::const_iterator neutral = neutrals.begin();
       neutral != neutrals.end(); ++neutral ) {
       if      ( std::abs((*neutral)->pdgId()) == 22 ) addPFCand(kIsolation, kGamma, convertToPtr(*neutral));
       else if ( std::abs((*neutral)->pdgId()) == 130 ) addPFCand(kIsolation, kNeutralHadron, convertToPtr(*neutral));
     };
   }
 }

template<typename InputIterator >

void reco::tau::RecoTauConstructor::addTauChargedHadrons	(	Region	region,
		const InputIterator &	begin,
		const InputIterator &	end
	)

inline

Add a list of charged hadrons to the input collection.

Definition at line 105 of file RecoTauConstructor.h.

References addPiZero(), addTauChargedHadron(), end, and reservePiZero().

Referenced by reco::tau::RecoTauBuilderCombinatoricPlugin::operator()().

     {
       for ( InputIterator iter = begin; iter != end; ++iter ) {
     addTauChargedHadron(region, *iter);
       }
     }

CandidatePtr reco::tau::RecoTauConstructor::convertToPtr ( const PFCandidatePtr & pfPtr ) const

private

Definition at line 238 of file RecoTauConstructor.cc.

References a, b, edm::Ptr< T >::isNonnull(), edm::Ptr< T >::key(), and pfCands_.

Referenced by addPFCands(), addTauChargedHadron(), setleadCand(), setleadChargedHadrCand(), and setleadNeutralCand().

                                          {
   if(candPtr.isNonnull()) {
     checkMatchedProductIds(candPtr, pfCands_);
     return CandidatePtr(pfCands_, candPtr.key());
   } else return PFCandidatePtr();
 }

CandidatePtr reco::tau::RecoTauConstructor::convertToPtr ( const CandidatePtr & candPtr ) const

private

Definition at line 219 of file RecoTauConstructor.cc.

References Exception.

                                      {
   return pfPtr;
 }

std::auto_ptr< reco::PFTau > reco::tau::RecoTauConstructor::get ( bool setupLeadingCandidates = true )

Definition at line 329 of file RecoTauConstructor.cc.

References begin, ALCARECOTkAlJpsiMuMu_cff::charge, muons2muons_cfi::chargedHadron, symbols::dm, end, getCollection(), kAll, kChargedHadron, reco::PFRecoTauChargedHadron::kChargedPFCandidate, kGamma, kIsolation, kSignal, reco::PFRecoTauChargedHadron::kTrack, reco::tau::leadCand(), LogDebug, minAbsPhotonSumPt_insideSignalCone_, minAbsPhotonSumPt_outsideSignalCone_, minRelPhotonSumPt_insideSignalCone_, minRelPhotonSumPt_outsideSignalCone_, hpstanc_transforms::nCharged, p4_, signalConeSize_, sortAndCopyIntoTau(), reco::tau::sumPFCandPt(), and tau_.

Referenced by Options.Options::__getitem__(), betterConfigParser.BetterConfigParser::__updateDict(), betterConfigParser.BetterConfigParser::getCompares(), betterConfigParser.BetterConfigParser::getGeneral(), betterConfigParser.BetterConfigParser::getResultingSection(), reco::tau::RecoTauBuilderCombinatoricPlugin::operator()(), and reco::tau::RecoTauBuilderConePlugin::operator()().

 {
   LogDebug("TauConstructorGet") << "Start getting" ;
 
   // Copy the sorted collections into the interal tau refvectors
   sortAndCopyIntoTau();
 
   // Setup all the important member variables of the tau
   // Set charge of tau
 //  tau_->setCharge(
 //      sumPFCandCharge(getCollection(kSignal, kChargedHadron)->begin(),
 //                      getCollection(kSignal, kChargedHadron)->end()));
   // CV: take charge of highest pT charged hadron as charge of tau,
   //     in case tau does not have three reconstructed tracks
   //    (either because tau is reconstructed as 2prong or because PFRecoTauChargedHadron is built from a PFNeutralHadron)
   unsigned int nCharged = 0;
   int charge = 0;
   double leadChargedHadronPt = 0.;
   int leadChargedHadronCharge = 0;
   for ( std::vector<PFRecoTauChargedHadron>::const_iterator chargedHadron = tau_->signalTauChargedHadronCandidatesRestricted().begin();
     chargedHadron != tau_->signalTauChargedHadronCandidatesRestricted().end(); ++chargedHadron ) {
     if ( chargedHadron->algoIs(PFRecoTauChargedHadron::kChargedPFCandidate) || chargedHadron->algoIs(PFRecoTauChargedHadron::kTrack) ) {
       ++nCharged;
       charge += chargedHadron->charge();
       if ( chargedHadron->pt() > leadChargedHadronPt ) {    
     leadChargedHadronPt = chargedHadron->pt();
     leadChargedHadronCharge = chargedHadron->charge();
       }
     }
   }
   if ( nCharged == 3 ) tau_->setCharge(charge);
   else tau_->setCharge(leadChargedHadronCharge);
 
   // Set PDG id
   tau_->setPdgId(tau_->charge() < 0 ? 15 : -15);
 
   // Set P4
   tau_->setP4(p4_);
 
   // Set Decay Mode
   double dRsignalCone = ( signalConeSize_ ) ? (*signalConeSize_)(*tau_) : 0.5;
   tau_->setSignalConeSize(dRsignalCone);
   PFTau::hadronicDecayMode dm = calculateDecayMode(
       *tau_, 
       dRsignalCone, 
       minAbsPhotonSumPt_insideSignalCone_, minRelPhotonSumPt_insideSignalCone_, minAbsPhotonSumPt_outsideSignalCone_, minRelPhotonSumPt_outsideSignalCone_);
   tau_->setDecayMode(dm);
 
   LogDebug("TauConstructorGet") << "Pt = " << tau_->pt() << ", eta = " << tau_->eta() << ", phi = " << tau_->phi() << ", mass = " << tau_->mass() << ", dm = " << tau_->decayMode() ;
 
   // Set charged isolation quantities
   tau_->setisolationPFChargedHadrCandsPtSum(
       sumPFCandPt(
         getCollection(kIsolation, kChargedHadron)->begin(),
         getCollection(kIsolation, kChargedHadron)->end()));
 
   // Set gamma isolation quantities
   tau_->setisolationPFGammaCandsEtSum(
       sumPFCandPt(
         getCollection(kIsolation, kGamma)->begin(),
         getCollection(kIsolation, kGamma)->end()));
 
   // Set em fraction
   tau_->setemFraction(sumPFCandPt(
           getCollection(kSignal, kGamma)->begin(),
           getCollection(kSignal, kGamma)->end()) / tau_->pt());
 
   if ( setupLeadingObjects ) {
     typedef std::vector<CandidatePtr>::const_iterator Iter;
     // Find the highest PT object in the signal cone
     Iter leadingCand = leadCand(
         getCollection(kSignal, kAll)->begin(),
         getCollection(kSignal, kAll)->end());
 
     if ( leadingCand != getCollection(kSignal, kAll)->end() )
       tau_->setleadCand(*leadingCand);
 
     // Hardest charged object in signal cone
     Iter leadingChargedCand = leadCand(
         getCollection(kSignal, kChargedHadron)->begin(),
         getCollection(kSignal, kChargedHadron)->end());
 
     if ( leadingChargedCand != getCollection(kSignal, kChargedHadron)->end() )
       tau_->setleadChargedHadrCand(*leadingChargedCand);
 
     // Hardest gamma object in signal cone
     Iter leadingGammaCand = leadCand(
         getCollection(kSignal, kGamma)->begin(),
         getCollection(kSignal, kGamma)->end());
 
     if(leadingGammaCand != getCollection(kSignal, kGamma)->end())
       tau_->setleadNeutralCand(*leadingGammaCand);
   }
   return tau_;
 }

std::vector< CandidatePtr > * reco::tau::RecoTauConstructor::getCollection	(	Region	region,
		ParticleType	type
	)

private

Definition at line 209 of file RecoTauConstructor.cc.

References collections_.

Referenced by get(), and reserve().

                                                                   {
     return collections_[std::make_pair(region, type)];
 }

RecoTauConstructor::SortedListPtr reco::tau::RecoTauConstructor::getSortedCollection	(	Region	region,
		ParticleType	type
	)

private

Definition at line 214 of file RecoTauConstructor.cc.

References sortedCollections_.

Referenced by addPFCand(), addTauChargedHadron(), and reserve().

                                                                         {
   return sortedCollections_[std::make_pair(region, type)];
 }

const reco::Candidate::LorentzVector& reco::tau::RecoTauConstructor::p4 ( ) const

inline

Definition at line 130 of file RecoTauConstructor.h.

References p4_.

Referenced by Tau.Tau::dxy_approx(), Tau.Tau::dz(), reco::tau::RecoTauBuilderCombinatoricPlugin::operator()(), and Lepton.Lepton::p4WithFSR().

130 { return p4_; }

reco::tau::RecoTauConstructor::p4_

reco::Candidate::LorentzVector p4_

Definition: RecoTauConstructor.h:165

void reco::tau::RecoTauConstructor::reserve	(	Region	region,
		ParticleType	type,
		size_t	size
	)

Reserve a set amount of space for a given RefVector.

Definition at line 73 of file RecoTauConstructor.cc.

References getCollection(), getSortedCollection(), kAll, and findQualityFiles::size.

Referenced by reco::tau::RecoTauBuilderCombinatoricPlugin::operator()(), reservePiZero(), and setleadCand().

                                                                              {
   getSortedCollection(region, type)->reserve(size);
   getCollection(region, type)->reserve(size);
   // Reserve global collection as well
   getSortedCollection(region, kAll)->reserve(
       getSortedCollection(region, kAll)->size() + size);
   getCollection(region, kAll)->reserve(
       getCollection(region, kAll)->size() + size);
 }

void reco::tau::RecoTauConstructor::reservePiZero	(	Region	region,
		size_t	size
	)

Reserve a set amount of space for the PiZeros.

Definition at line 173 of file RecoTauConstructor.cc.

References copyGammas_, kGamma, kIsolation, kSignal, reserve(), and tau_.

Referenced by addTauChargedHadrons(), and reco::tau::RecoTauBuilderCombinatoricPlugin::operator()().

 {
   if ( region == kSignal ) {
     tau_->signalPiZeroCandidatesRestricted().reserve(size);
     // If we are building the gammas with the pizeros, resize that
     // vector as well
     if ( copyGammas_ ) reserve(kSignal, kGamma, 2*size);
   } else {
     tau_->isolationPiZeroCandidatesRestricted().reserve(size);
     if ( copyGammas_ ) reserve(kIsolation, kGamma, 2*size);
   }
 }

void reco::tau::RecoTauConstructor::reserveTauChargedHadron	(	Region	region,
		size_t	size
	)

Reserve a set amount of space for the ChargedHadrons.

Definition at line 83 of file RecoTauConstructor.cc.

References g4TestGeometry_cfi::checkOverlap(), edm::Ptr< T >::id(), edm::Ptr< T >::key(), kSignal, LogDebug, boostedElectronIsolation_cff::pfGamma, reco::tau::pfGammas(), edm::Ptr< T >::refCore(), and tau_.

Referenced by addPFCands().

 {
   if ( region == kSignal ) {
     tau_->signalTauChargedHadronCandidatesRestricted().reserve(size);
     tau_->selectedSignalChargedHadrCands_.reserve(size);
   } else {
     tau_->isolationTauChargedHadronCandidatesRestricted().reserve(size);
     tau_->selectedIsolationChargedHadrCands_.reserve(size);
   }
 }

template<typename T >

void reco::tau::RecoTauConstructor::setleadCand ( const T & cand )

inline

Set leading PF candidate.

Definition at line 79 of file RecoTauConstructor.h.

References addPFCand(), convertToPtr(), reserve(), findQualityFiles::size, and tau_.

Referenced by reco::tau::RecoTauBuilderConePlugin::operator()().

                                                          {
       tau_->setleadCand(convertToPtr(cand));
     }

template<typename T >

void reco::tau::RecoTauConstructor::setleadChargedHadrCand ( const T & cand )

inline

Set leading PFChargedHadron candidate.

Definition at line 69 of file RecoTauConstructor.h.

References convertToPtr(), and tau_.

Referenced by reco::tau::RecoTauBuilderConePlugin::operator()().

                                                                     {
       tau_->setleadChargedHadrCand(convertToPtr(cand));
     }

template<typename T >

void reco::tau::RecoTauConstructor::setleadNeutralCand ( const T & cand )

inline

Set leading PFGamma candidate.

Definition at line 74 of file RecoTauConstructor.h.

References convertToPtr(), and tau_.

Referenced by reco::tau::RecoTauBuilderConePlugin::operator()().

                                                                 {
       tau_->setleadNeutralCand(convertToPtr(cand));
     }

void reco::tau::RecoTauConstructor::sortAndCopyIntoTau ( )

private

Definition at line 255 of file RecoTauConstructor.cc.

References collections_, reco::deltaR(), reco::PFTau::kNull, reco::PFTau::kOneProngNPiZero, reco::PFTau::kRareDecayMode, RecoTauCombinatoricProducer_cfi::maxPiZeros, RecoTauCombinatoricProducer_cfi::minAbsPhotonSumPt_insideSignalCone, RecoTauCombinatoricProducer_cfi::minAbsPhotonSumPt_outsideSignalCone, RecoTauCombinatoricProducer_cfi::minRelPhotonSumPt_insideSignalCone, RecoTauCombinatoricProducer_cfi::minRelPhotonSumPt_outsideSignalCone, hpstanc_transforms::nCharged, hpstanc_transforms::nPiZeros, reco::Candidate::p4(), reco::LeafCandidate::p4(), muons2muons_cfi::photon, reco::Candidate::pt(), reco::LeafCandidate::pt(), reco::PFTau::signalPiZeroCandidates(), reco::PFTau::signalTauChargedHadronCandidates(), jetUpdater_cfi::sort, sortedCollections_, metsig::tau, and tau_.

Referenced by get().

                                             {
   // The charged hadrons and pizeros are a special case, as we can sort them in situ
   std::sort(tau_->signalTauChargedHadronCandidatesRestricted().begin(),
             tau_->signalTauChargedHadronCandidatesRestricted().end(),
             ptDescending<PFRecoTauChargedHadron>);
   std::sort(tau_->isolationTauChargedHadronCandidatesRestricted().begin(),
             tau_->isolationTauChargedHadronCandidatesRestricted().end(),
             ptDescending<PFRecoTauChargedHadron>);
   std::sort(tau_->signalPiZeroCandidatesRestricted().begin(),
             tau_->signalPiZeroCandidatesRestricted().end(),
             ptDescending<RecoTauPiZero>);
   std::sort(tau_->isolationPiZeroCandidatesRestricted().begin(),
             tau_->isolationPiZeroCandidatesRestricted().end(),
             ptDescending<RecoTauPiZero>);
 
   // Sort each of our sortable collections, and copy them into the final
   // tau RefVector.
   for (auto const& colkey : collections_ ) {
     SortedListPtr sortedCollection = sortedCollections_[colkey.first];
     std::sort(sortedCollection->begin(),
               sortedCollection->end(),
               ptDescendingPtr<CandidatePtr>);
     // Copy into the real tau collection
     for ( std::vector<CandidatePtr>::const_iterator particle = sortedCollection->begin();
       particle != sortedCollection->end(); ++particle ) {
       colkey.second->push_back(*particle);
     }
   }
 }

Member Data Documentation

CollectionMap reco::tau::RecoTauConstructor::collections_

private

Definition at line 159 of file RecoTauConstructor.h.

Referenced by getCollection(), RecoTauConstructor(), and sortAndCopyIntoTau().

bool reco::tau::RecoTauConstructor::copyGammas_

private

Definition at line 138 of file RecoTauConstructor.h.

Referenced by addPFCand(), addPiZero(), addTauChargedHadron(), RecoTauConstructor(), and reservePiZero().

double reco::tau::RecoTauConstructor::minAbsPhotonSumPt_insideSignalCone_

private

Definition at line 141 of file RecoTauConstructor.h.

Referenced by get().

double reco::tau::RecoTauConstructor::minAbsPhotonSumPt_outsideSignalCone_

private

Definition at line 143 of file RecoTauConstructor.h.

Referenced by get().

double reco::tau::RecoTauConstructor::minRelPhotonSumPt_insideSignalCone_

private

Definition at line 142 of file RecoTauConstructor.h.

Referenced by get().

double reco::tau::RecoTauConstructor::minRelPhotonSumPt_outsideSignalCone_

private

Definition at line 144 of file RecoTauConstructor.h.

Referenced by get().

reco::Candidate::LorentzVector reco::tau::RecoTauConstructor::p4_

private

Definition at line 165 of file RecoTauConstructor.h.

Referenced by addPFCand(), addPiZero(), addTauChargedHadron(), get(), and p4().

const edm::Handle<edm::View<reco::Candidate> >& reco::tau::RecoTauConstructor::pfCands_

private

Definition at line 157 of file RecoTauConstructor.h.

Referenced by convertToPtr().

const StringObjectFunction<reco::PFTau>* reco::tau::RecoTauConstructor::signalConeSize_

private

Definition at line 140 of file RecoTauConstructor.h.

Referenced by get().

SortedCollectionMap reco::tau::RecoTauConstructor::sortedCollections_

private

Definition at line 162 of file RecoTauConstructor.h.

Referenced by getSortedCollection(), RecoTauConstructor(), and sortAndCopyIntoTau().

std::auto_ptr<reco::PFTau> reco::tau::RecoTauConstructor::tau_

private

Definition at line 158 of file RecoTauConstructor.h.

Referenced by addPiZero(), addTauChargedHadron(), get(), RecoTauConstructor(), reservePiZero(), reserveTauChargedHadron(), setleadCand(), setleadChargedHadrCand(), setleadNeutralCand(), and sortAndCopyIntoTau().

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation