Templated PAT object container. More...

#include "DataFormats/PatCandidates/interface/PATObject.h"

Inheritance diagram for pat::PATObject< ObjectType >:

Public Types
typedef ObjectType	base_type

Public Member Functions
void	addGenParticleRef (const reco::GenParticleRef &ref)

void	addTriggerObjectMatch (const TriggerObjectStandAlone &trigObj)
	add a trigger match More...

void	addUserCand (const std::string &label, const reco::CandidatePtr &data, const bool overwrite=false)
	Set user-defined int. More...

template<typename T >
void	addUserData (const std::string &label, const T &data, bool transientOnly=false, bool overwrite=false)

void	addUserDataFromPtr (const std::string &label, const edm::Ptr< pat::UserData > &data, bool overwrite=false)

void	addUserFloat (const std::string &label, float data, const bool overwrite=false)
	Set user-defined float. More...

void	addUserInt (const std::string &label, int32_t data, const bool overwrite=false)
	Set user-defined int. More...

std::vector< std::pair< std::string, pat::LookupTableRecord > >	efficiencies () const
	Returns the efficiencies as <name,value> pairs (by value) More...

const pat::LookupTableRecord &	efficiency (const std::string &name) const
	Returns an efficiency given its name. More...

const std::vector< std::string > &	efficiencyNames () const
	Returns the list of the names of the stored efficiencies. More...

const std::vector< pat::LookupTableRecord > &	efficiencyValues () const
	Returns the list of the values of the stored efficiencies (the ordering is the same as in efficiencyNames()) More...

void	embedGenParticle ()

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

reco::GenParticleRef	genParticleById (int pdgId, int status, uint8_t autoCharge=0) const

reco::GenParticleRef	genParticleRef (size_t idx=0) const

std::vector< reco::GenParticleRef >	genParticleRefs () const

size_t	genParticlesSize () const
	Number of generator level particles stored as ref or embedded. More...

const pat::CandKinResolution &	getKinResolution (const std::string &label="") const

bool	hasKinResolution (const std::string &label="") const
	Check if the kinematic resolutions are stored into this object (possibly specifying a label for them) More...

bool	hasOverlaps (const std::string &label) const
	Returns true if there was at least one overlap for this test label. More...

bool	hasUserCand (const std::string &key) const
	Return true if there is a user-defined int with a given name. More...

bool	hasUserData (const std::string &key) const
	Check if user data with a specific type is present. More...

bool	hasUserFloat (const std::string &key) const
	Return true if there is a user-defined float with a given name. More...

bool	hasUserFloat (const char *key) const
	a CINT-friendly interface More...

bool	hasUserInt (const std::string &key) const
	Return true if there is a user-defined int with a given name. More...

const reco::Candidate *	originalObject () const
	access to the original object; returns zero for null Ref and throws for unavailable collection More...

const edm::Ptr< reco::Candidate > &	originalObjectRef () const
	reference to original object. Returns a null reference if not available More...

const std::vector< std::string > &	overlapLabels () const
	Returns the labels of the overlap tests that found at least one overlap. More...

const reco::CandidatePtrVector &	overlaps (const std::string &label) const

	PATObject ()
	default constructor More...

	PATObject (const ObjectType &obj)
	constructor from a base object (leaves invalid reference to original object!) More...

	PATObject (const edm::RefToBase< ObjectType > &ref)
	constructor from reference More...

	PATObject (const edm::Ptr< ObjectType > &ref)
	constructor from reference More...

double	resolE (const std::string &label="") const
	Resolution on energy, possibly with a label to specify which resolution to use. More...

double	resolEt (const std::string &label="") const
	Resolution on et, possibly with a label to specify which resolution to use. More...

double	resolEta (const std::string &label="") const
	Resolution on eta, possibly with a label to specify which resolution to use. More...

double	resolM (const std::string &label="") const

double	resolP (const std::string &label="") const
	Resolution on p, possibly with a label to specify which resolution to use. More...

double	resolPhi (const std::string &label="") const
	Resolution on phi, possibly with a label to specify which resolution to use. More...

double	resolPInv (const std::string &label="") const
	Resolution on 1/p, possibly with a label to specify which resolution to use. More...

double	resolPt (const std::string &label="") const
	Resolution on pt, possibly with a label to specify which resolution to use. More...

double	resolPx (const std::string &label="") const
	Resolution on px, possibly with a label to specify which resolution to use. More...

double	resolPy (const std::string &label="") const
	Resolution on py, possibly with a label to specify which resolution to use. More...

double	resolPz (const std::string &label="") const
	Resolution on pz, possibly with a label to specify which resolution to use. More...

double	resolTheta (const std::string &label="") const
	Resolution on theta, possibly with a label to specify which resolution to use. More...

void	setEfficiency (const std::string &name, const pat::LookupTableRecord &value)

void	setGenParticle (const reco::GenParticle &particle)
	Set the generator level particle from a particle not in the Event (embedding it, of course) More...

void	setGenParticleRef (const reco::GenParticleRef &ref, bool embed=false)
	Set the generator level particle reference. More...

void	setKinResolution (const pat::CandKinResolution &resol, const std::string &label="")
	Add a kinematic resolution to this object (possibly with a label) More...

void	setOverlaps (const std::string &label, const reco::CandidatePtrVector &overlaps)

const TriggerObjectStandAlone *	triggerObjectMatch (const size_t idx=0) const
	get one matched trigger object by index More...

const TriggerObjectStandAlone *	triggerObjectMatchByAlgorithm (const std::string &nameAlgorithm, const bool algoCondAccepted=true, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByAlgorithm (const char *nameAlgorithm, const bool algoCondAccepted=true, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByAlgorithm (const std::string &nameAlgorithm, const unsigned algoCondAccepted, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByAlgorithm (const char *nameAlgorithm, const unsigned algoCondAccepted, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByCollection (const std::string &coll, const size_t idx=0) const
	get one matched trigger object from a certain collection by index More...

const TriggerObjectStandAlone *	triggerObjectMatchByCollection (const char *coll, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByCondition (const std::string &nameCondition, const size_t idx=0) const
	get one matched L1 object used in a succeeding object combination of a certain L1 condition by index More...

const TriggerObjectStandAlone *	triggerObjectMatchByCondition (const char *nameCondition, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByFilter (const std::string &labelFilter, const size_t idx=0) const
	get one matched HLT object used in a certain HLT filter by index More...

const TriggerObjectStandAlone *	triggerObjectMatchByFilter (const char *labelFilter, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByFilterID (const unsigned triggerObjectType, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByPath (const std::string &namePath, const bool pathLastFilterAccepted=false, const bool pathL3FilterAccepted=true, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByPath (const char *namePath, const bool pathLastFilterAccepted=false, const bool pathL3FilterAccepted=true, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByPath (const std::string &namePath, const unsigned pathLastFilterAccepted, const unsigned pathL3FilterAccepted=1, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByPath (const char *namePath, const unsigned pathLastFilterAccepted, const unsigned pathL3FilterAccepted=1, const size_t idx=0) const

const TriggerObjectStandAlone *	triggerObjectMatchByType (const trigger::TriggerObjectType triggerObjectType, const size_t idx=0) const
	get one matched trigger object of a certain type by index More...

const TriggerObjectStandAlone *	triggerObjectMatchByType (const unsigned triggerObjectType, const size_t idx=0) const

const TriggerObjectStandAloneCollection &	triggerObjectMatches () const
	get all matched trigger objects More...

const TriggerObjectStandAloneCollection	triggerObjectMatchesByAlgorithm (const std::string &nameAlgorithm, const bool algoCondAccepted=true) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByAlgorithm (const char *nameAlgorithm, const bool algoCondAccepted=true) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByAlgorithm (const std::string &nameAlgorithm, const unsigned algoCondAccepted) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByAlgorithm (const char *nameAlgorithm, const unsigned algoCondAccepted) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByCollection (const std::string &coll) const
	get all matched trigger objects from a certain collection More...

const TriggerObjectStandAloneCollection	triggerObjectMatchesByCollection (const char *coll) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByCondition (const std::string &nameCondition) const
	get all matched L1 objects used in a succeeding object combination of a certain L1 condition More...

const TriggerObjectStandAloneCollection	triggerObjectMatchesByCondition (const char *nameCondition) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByFilter (const std::string &labelFilter) const
	get all matched HLT objects used in a certain HLT filter More...

const TriggerObjectStandAloneCollection	triggerObjectMatchesByFilter (const char *labelFilter) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByFilterID (const unsigned triggerObjectType) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByPath (const std::string &namePath, const bool pathLastFilterAccepted=false, const bool pathL3FilterAccepted=true) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByPath (const char *namePath, const bool pathLastFilterAccepted=false, const bool pathL3FilterAccepted=true) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByPath (const std::string &namePath, const unsigned pathLastFilterAccepted, const unsigned pathL3FilterAccepted=1) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByPath (const char *namePath, const unsigned pathLastFilterAccepted, const unsigned pathL3FilterAccepted=1) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByType (const trigger::TriggerObjectType triggerObjectType) const

const TriggerObjectStandAloneCollection	triggerObjectMatchesByType (const unsigned triggerObjectType) const

void	unpackTriggerObjectPathNames (const edm::TriggerNames &names)
	unpack path names of matched trigger objects (if they were packed before embedding, which is not normally the case) More...

reco::CandidatePtr	userCand (const std::string &key) const

const std::vector< std::string > &	userCandNames () const
	Get list of user-defined cand names. More...

template<typename T >
const T *	userData (const std::string &key) const
	Returns user-defined data. Returns NULL if the data is not present, or not of type T. More...

const void *	userDataBare (const std::string &key) const

const std::vector< std::string > &	userDataNames () const
	Get list of user data object names. More...

const std::string &	userDataObjectType (const std::string &key) const
	Get human-readable type of user data object, for debugging. More...

float	userFloat (const std::string &key) const

float	userFloat (const char *key) const
	a CINT-friendly interface More...

const std::vector< std::string > &	userFloatNames () const
	Get list of user-defined float names. More...

std::vector< float >	userFloatRange (const std::string &key) const
	return a range of values corresponding to key More...

int32_t	userInt (const std::string &key) const

const std::vector< std::string > &	userIntNames () const
	Get list of user-defined int names. More...

std::vector< int >	userIntRange (const std::string &key) const
	returns a range of values corresponding to key More...

virtual	~PATObject ()
	destructor More...

Protected Member Functions
void	addUserDataObject_ (const std::string &label, std::unique_ptr< pat::UserData > value, bool overwrite=false)

Protected Attributes
std::vector< std::string >	efficiencyNames_
	vector of the efficiencies (names) More...

std::vector< pat::LookupTableRecord >	efficiencyValues_
	vector of the efficiencies (values) More...

std::vector< reco::GenParticle >	genParticleEmbedded_
	vector to hold an embedded generator level particle More...

std::vector< reco::GenParticleRef >	genParticleRef_
	Reference to a generator level particle. More...

std::vector< std::string >	kinResolutionLabels_

std::vector< pat::CandKinResolution >	kinResolutions_
	Kinematic resolutions. More...

std::vector< reco::CandidatePtrVector >	overlapItems_
	Overlapping items (sorted by distance) More...

std::vector< std::string >	overlapLabels_
	Overlapping test labels (only if there are any overlaps) More...

edm::Ptr< reco::Candidate >	refToOrig_

TriggerObjectStandAloneCollection	triggerObjectMatchesEmbedded_
	vector of trigger matches More...

std::vector< std::string >	userCandLabels_

std::vector< reco::CandidatePtr >	userCands_

std::vector< std::string >	userDataLabels_
	User data object. More...

pat::UserDataCollection	userDataObjects_

std::vector< std::string >	userFloatLabels_

std::vector< float >	userFloats_

std::vector< std::string >	userIntLabels_

std::vector< int32_t >	userInts_

Private Member Functions
const pat::UserData *	userDataObject_ (const std::string &key) const

Detailed Description

template<class ObjectType>
class pat::PATObject< ObjectType >

Templated PAT object container.

PATObject is the templated base PAT object that wraps around reco objects.

Please post comments and questions to the Physics Tools hypernews: https://hypernews.cern.ch/HyperNews/CMS/get/physTools.html

Author: Steven Lowette, Giovanni Petrucciani, Frederic Ronga, Volker Adler, Sal Rappoccio

Definition at line 49 of file PATObject.h.

Member Typedef Documentation

template<class ObjectType>

typedef ObjectType pat::PATObject< ObjectType >::base_type

Definition at line 52 of file PATObject.h.

Constructor & Destructor Documentation

template<class ObjectType >

pat::PATObject< ObjectType >::PATObject ( )

default constructor

Definition at line 467 of file PATObject.h.

467 {

468 }

template<class ObjectType>

pat::PATObject< ObjectType >::PATObject ( const ObjectType & obj )

constructor from a base object (leaves invalid reference to original object!)

Definition at line 470 of file PATObject.h.

                                                                                      :
     ObjectType(obj),
     refToOrig_() {
   }

template<class ObjectType>

pat::PATObject< ObjectType >::PATObject ( const edm::RefToBase< ObjectType > & ref )

constructor from reference

Definition at line 475 of file PATObject.h.

                                                                                                    :
     ObjectType(*ref),
     refToOrig_(ref.id(), ref.get(), ref.key()) // correct way to convert RefToBase=>Ptr, if ref is guaranteed to be available
                                                // which happens to be true, otherwise the line before this throws ex. already
       {
       }

template<class ObjectType>

pat::PATObject< ObjectType >::PATObject ( const edm::Ptr< ObjectType > & ref )

constructor from reference

Definition at line 482 of file PATObject.h.

                                                                                              :
     ObjectType(*ref),
     refToOrig_(ref) {
   }

template<class ObjectType>

virtual pat::PATObject< ObjectType >::~PATObject ( )

inlinevirtual

destructor

Definition at line 63 of file PATObject.h.

63 {}

Member Function Documentation

template<class ObjectType >

void pat::PATObject< ObjectType >::addGenParticleRef ( const reco::GenParticleRef & ref )

Add a generator level particle reference If there is already an embedded particle, this ref will be embedded too

Definition at line 678 of file PATObject.h.

References pat::PATObject< ObjectType >::genParticleEmbedded_, pat::PATObject< ObjectType >::genParticleRef_, and edm::Ref< C, T, F >::isNonnull().

Referenced by pat::PATElectronProducer::fillElectron(), pat::PATElectronProducer::fillElectron2(), pat::PATMuonProducer::fillMuon(), pat::PATGenericParticleProducer::produce(), pat::PATPFParticleProducer::produce(), pat::PATTauProducer::produce(), and pat::PATPhotonProducer::produce().

                                                                              {
       if (!genParticleEmbedded_.empty()) { // we're embedding
           if (ref.isNonnull()) genParticleEmbedded_.push_back(*ref);
       } else {
           genParticleRef_.push_back(ref);
       }
   }

template<class ObjectType>

void pat::PATObject< ObjectType >::addTriggerObjectMatch ( const TriggerObjectStandAlone & trigObj )

inline

add a trigger match

Definition at line 204 of file PATObject.h.

204 { triggerObjectMatchesEmbedded_.push_back( trigObj ); };

pat::PATObject::triggerObjectMatchesEmbedded_

TriggerObjectStandAloneCollection triggerObjectMatchesEmbedded_

vector of trigger matches

Definition: PATObject.h:424

template<class ObjectType >

void pat::PATObject< ObjectType >::addUserCand	(	const std::string &	label,
		const reco::CandidatePtr &	data,
		const bool	overwrite = `false`
	)

Set user-defined int.

Definition at line 884 of file PATObject.h.

References data, SoftLeptonByDistance_cfi::distance, diffTwoXMLs::label, pat::PATObject< ObjectType >::userCandLabels_, and pat::PATObject< ObjectType >::userCands_.

   {
     auto it = std::lower_bound(userCandLabels_.begin(),userCandLabels_.end(),label);
     const auto dist = std::distance(userCandLabels_.begin(),it);
     if( it == userCandLabels_.end() || *it != label ) {      
       userCandLabels_.insert(it,label);
       userCands_.insert(userCands_.begin()+dist,data);
     } else if( overwrite ) {
       userCands_[dist] = data;
     } else {
       userCandLabels_.insert(it+1,label);
       userCands_.insert(userCands_.begin()+dist+1,data);
     }    
   }

template<class ObjectType>

template<typename T >

void pat::PATObject< ObjectType >::addUserData	(	const std::string &	label,
		const T &	data,
		bool	transientOnly = `false`,
		bool	overwrite = `false`
	)

inline

Set user-defined data Needs dictionaries for T and for pat::UserHolder<T>, and it will throw exception if they're missing, unless transientOnly is set to true

Definition at line 309 of file PATObject.h.

Referenced by OniaPhotonConversionProducer::makePhotonCandidate(), OniaAddV0TracksProducer::produce(), Onia2MuMuPAT::produce(), and BPHWriteSpecificDecay::write().

                                                                                                                   {
         std::unique_ptr<pat::UserData> made(pat::UserData::make<T>(data, transientOnly));
         addUserDataObject_( label, std::move(made), overwrite );
       }

template<class ObjectType>

void pat::PATObject< ObjectType >::addUserDataFromPtr	(	const std::string &	label,
		const edm::Ptr< pat::UserData > &	data,
		bool	overwrite = `false`
	)

inline

Set user-defined data. To be used only to fill from ValueMap<Ptr<UserData>> Do not use unless you know what you are doing.

Definition at line 316 of file PATObject.h.

                                                                                                                  {
         std::unique_ptr<pat::UserData> cloned(data->clone());
         addUserDataObject_( label, std::move(cloned), overwrite );
       }

template<class ObjectType >

void pat::PATObject< ObjectType >::addUserDataObject_	(	const std::string &	label,
		std::unique_ptr< pat::UserData >	value,
		bool	overwrite = `false`
	)

protected

Definition at line 773 of file PATObject.h.

References edm::OwnVector< T, P >::begin(), SoftLeptonByDistance_cfi::distance, edm::OwnVector< T, P >::insert(), diffTwoXMLs::label, eostools::move(), edm::OwnVector< T, P >::set(), pat::PATObject< ObjectType >::userDataLabels_, and pat::PATObject< ObjectType >::userDataObjects_.

   {
     auto it = std::lower_bound(userDataLabels_.begin(), userDataLabels_.end(), label);
     const auto dist = std::distance(userDataLabels_.begin(), it);
     if( it == userDataLabels_.end() || *it != label ) {
         userDataLabels_.insert(it,label);
         userDataObjects_.insert(userDataObjects_.begin()+dist, std::move(data));
     } else if( overwrite ) {
         userDataObjects_.set(dist, std::move(data));
     } else {
         //create a range by adding behind the first entry
         userDataLabels_.insert(it+1,label);
         userDataObjects_.insert(userDataObjects_.begin()+dist+1, std::move(data));
     }
   }

template<class ObjectType >

void pat::PATObject< ObjectType >::addUserFloat	(	const std::string &	label,
		float	data,
		const bool	overwrite = `false`
	)

Set user-defined float.

Definition at line 813 of file PATObject.h.

References data, SoftLeptonByDistance_cfi::distance, diffTwoXMLs::label, pat::PATObject< ObjectType >::userFloatLabels_, and pat::PATObject< ObjectType >::userFloats_.

Referenced by ZeeCandidateFilter::filter(), ZMuMuTrackUserData::produce(), ZMuMuMuonUserData::produce(), pat::PATPhotonSlimmer::produce(), ZMuMuUserData::produce(), ZMuMuUserDataOneTrack::produce(), Onia2MuMuPAT::produce(), PatJPsiProducer::produce(), and BPHWriteSpecificDecay::write().

   {
     auto it = std::lower_bound(userFloatLabels_.begin(),userFloatLabels_.end(),label);
     const auto dist = std::distance(userFloatLabels_.begin(),it);
     if( it == userFloatLabels_.end() || *it != label ) {      
       userFloatLabels_.insert(it,label);
       userFloats_.insert(userFloats_.begin()+dist,data);
     } else if( overwrite ) {
       userFloats_[ dist ] = data;
     } else {
       //create a range by adding behind the first entry
       userFloatLabels_.insert(it+1,label);
       userFloats_.insert(userFloats_.begin()+dist+1, data); 
     }
   }

template<class ObjectType>

void pat::PATObject< ObjectType >::addUserInt	(	const std::string &	label,
		int32_t	data,
		const bool	overwrite = `false`
	)

Set user-defined int.

Definition at line 855 of file PATObject.h.

References data, SoftLeptonByDistance_cfi::distance, diffTwoXMLs::label, pat::PATObject< ObjectType >::userIntLabels_, and pat::PATObject< ObjectType >::userInts_.

Referenced by ZeeCandidateFilter::filter(), and Onia2MuMuPAT::produce().

   {
     auto it = std::lower_bound(userIntLabels_.begin(),userIntLabels_.end(),label);
     const auto dist = std::distance(userIntLabels_.begin(),it);
     if( it == userIntLabels_.end() || *it != label ) { 
       userIntLabels_.insert(it,label);
       userInts_.insert(userInts_.begin()+dist,data);
     } else if( overwrite ) {
       userInts_[dist] = data;
     } else {
       //create a range by adding behind the first entry
       userIntLabels_.insert(it+1, label);
       userInts_.insert(userInts_.begin()+dist+1,data);
     }
   }

template<class ObjectType >

std::vector< std::pair< std::string, pat::LookupTableRecord > > pat::PATObject< ObjectType >::efficiencies ( ) const

Returns the efficiencies as <name,value> pairs (by value)

Definition at line 644 of file PATObject.h.

References pat::PATObject< ObjectType >::efficiencyNames_, and pat::PATObject< ObjectType >::efficiencyValues_.

                                             {
     std::vector<std::pair<std::string,pat::LookupTableRecord> > ret;
     std::vector<std::string>::const_iterator itn = efficiencyNames_.begin(), edn = efficiencyNames_.end();
     std::vector<pat::LookupTableRecord>::const_iterator itv = efficiencyValues_.begin();
     for ( ; itn != edn; ++itn, ++itv) {
         ret.emplace_back( *itn, *itv);
     }
     return ret;
   }

template<class ObjectType >

const pat::LookupTableRecord & pat::PATObject< ObjectType >::efficiency ( const std::string & name ) const

Returns an efficiency given its name.

Definition at line 633 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, pat::PATObject< ObjectType >::efficiencyNames_, pat::PATObject< ObjectType >::efficiencyValues_, Exception, and dataset::name.

                                                                {
     // find the name in the (sorted) list of names
     auto it = std::lower_bound(efficiencyNames_.cbegin(), efficiencyNames_.cend(), name);
     if ((it == efficiencyNames_.end()) || (*it != name)) {
         throw cms::Exception("Invalid Label") << "There is no efficiency with name '" << name << "' in this PAT Object\n";
     }
     return efficiencyValues_[std::distance(efficiencyNames_.cbegin(),it)];
   }

template<class ObjectType>

const std::vector<std::string>& pat::PATObject< ObjectType >::efficiencyNames ( ) const

inline

Returns the list of the names of the stored efficiencies.

Definition at line 215 of file PATObject.h.

215 { return efficiencyNames_; }

pat::PATObject::efficiencyNames_

std::vector< std::string > efficiencyNames_

vector of the efficiencies (names)

Definition: PATObject.h:429

template<class ObjectType>

const std::vector<pat::LookupTableRecord>& pat::PATObject< ObjectType >::efficiencyValues ( ) const

inline

Returns the list of the values of the stored efficiencies (the ordering is the same as in efficiencyNames())

Definition at line 217 of file PATObject.h.

217 { return efficiencyValues_; }

pat::PATObject::efficiencyValues_

std::vector< pat::LookupTableRecord > efficiencyValues_

vector of the efficiencies (values)

Definition: PATObject.h:427

template<class ObjectType >

void pat::PATObject< ObjectType >::embedGenParticle ( )

Embed the generator level particle(s) in this PATObject Note that generator level particles can only be all embedded or all not embedded.

Definition at line 694 of file PATObject.h.

References pat::PATObject< ObjectType >::genParticleEmbedded_, and pat::PATObject< ObjectType >::genParticleRef_.

Referenced by pat::PATElectronProducer::fillElectron(), pat::PATElectronProducer::fillElectron2(), pat::PATMuonProducer::fillMuon(), Onia2MuMuPAT::produce(), pat::PATGenericParticleProducer::produce(), pat::PATPFParticleProducer::produce(), pat::PATTauProducer::produce(), pat::PATPhotonProducer::produce(), and pat::PATObject< ObjectType >::setGenParticleRef().

                                                {
       genParticleEmbedded_.clear();
       for (std::vector<reco::GenParticleRef>::const_iterator it = genParticleRef_.begin(); it != genParticleRef_.end(); ++it) {
           if (it->isNonnull()) genParticleEmbedded_.push_back(**it);
       }
       genParticleRef_.clear();
   }

template<class ObjectType>

const reco::GenParticle* pat::PATObject< ObjectType >::genParticle ( size_t idx = 0 ) const

inline

Get generator level particle, as C++ pointer (might be 0 if the ref was null) If you stored multiple GenParticles, you can specify which one you want.

Definition at line 244 of file PATObject.h.

Referenced by gamma_radiative_analyzer::analyze(), ZMuMu_Radiative_analyzer::analyze(), EmbeddingLHEProducer::assign_4vector(), and pat::Lepton< reco::Muon >::genLepton().

                                                                  {
             reco::GenParticleRef ref = genParticleRef(idx);
             return ref.isNonnull() ? ref.get() : 0;
       }

template<class ObjectType >

reco::GenParticleRef pat::PATObject< ObjectType >::genParticleById	(	int	pdgId,
		int	status,
		uint8_t	autoCharge = `0`
	)		const

Get a generator level particle reference with a given pdg id and status If there is no MC match with that pdgId and status, it will return a null ref Note: this might be a transient ref if the genParticle was embedded If status == 0, only the pdgId will be checked; likewise, if pdgId == 0, only the status will be checked. When autoCharge is set to true, and a charged reco particle is matched to a charged gen particle, positive pdgId means 'same charge', negative pdgId means 'opposite charge'; for example, electron.genParticleById(11,0,true) will get an e^+ matched to e^+ or e^- matched to e^-, while genParticleById(-15,0,true) will get e^+ matched to e^- or vice versa. If a neutral reco particle is matched to a charged gen particle, the sign of the pdgId passed to getParticleById must match that of the gen particle; for example photon.getParticleById(11) will match gamma to e^-, while genParticleById(-11) will match gamma to e^+ (pdgId=-11)

Definition at line 713 of file PATObject.h.

References funct::abs(), ALCARECOTkAlJpsiMuMu_cff::charge, reco::LeafCandidate::charge(), end, g, pat::PATObject< ObjectType >::genParticleEmbedded_, pat::PATObject< ObjectType >::genParticleRef_, pat::PATObject< ObjectType >::genParticleRefs(), reco::LeafCandidate::pdgId(), mps_update::status, and reco::LeafCandidate::status().

                                                                                                            {
         // get a vector, avoiding an unneeded copy if there is no embedding
         const std::vector<reco::GenParticleRef> & vec = (genParticleEmbedded_.empty() ? genParticleRef_ : genParticleRefs());
         for (std::vector<reco::GenParticleRef>::const_iterator ref = vec.begin(), end = vec.end(); ref != end; ++ref) {
             if (ref->isNonnull()) {
                 const reco::GenParticle & g = **ref;
                 if ((status != 0) && (g.status() != status)) continue;
                 if (pdgId == 0) {
                     return *ref;
                 } else if (!autoCharge) {
                     if (pdgId == g.pdgId()) return *ref;
                 } else if (abs(pdgId) == abs(g.pdgId())) {
                     // I want pdgId > 0 to match "correct charge" (for charged particles)
                     if (g.charge() == 0) return *ref;
                     else if ((this->charge() == 0) && (pdgId == g.pdgId())) return *ref;
                     else if (g.charge()*this->charge()*pdgId > 0) return *ref;
                 }
             }
         }
         return reco::GenParticleRef();
   }

template<class ObjectType>

reco::GenParticleRef pat::PATObject< ObjectType >::genParticleRef ( size_t idx = 0 ) const

inline

Get generator level particle reference (might be a transient ref if the genParticle was embedded) If you stored multiple GenParticles, you can specify which one you want.

Definition at line 225 of file PATObject.h.

Referenced by DimuonStatistics::analyze(), and DimuonMCMatcher::produce().

                                                                  {
             if (idx >= genParticlesSize()) return reco::GenParticleRef();
             return genParticleEmbedded_.empty() ? genParticleRef_[idx] : reco::GenParticleRef(&genParticleEmbedded_, idx);
       }

template<class ObjectType >

std::vector< reco::GenParticleRef > pat::PATObject< ObjectType >::genParticleRefs ( ) const

Return the list of generator level particles. Note that the refs can be transient refs to embedded GenParticles

Definition at line 703 of file PATObject.h.

References pat::PATObject< ObjectType >::genParticleEmbedded_, pat::PATObject< ObjectType >::genParticleRef_, mps_fire::i, and gen::n.

Referenced by pat::PATObject< ObjectType >::genParticleById(), and getGenTau().

                                                                              {
         if (genParticleEmbedded_.empty()) return genParticleRef_;
         std::vector<reco::GenParticleRef> ret(genParticleEmbedded_.size());
         for (size_t i = 0, n = ret.size(); i < n; ++i) {
             ret[i] = reco::GenParticleRef(&genParticleEmbedded_, i);
         }
         return ret;
   }

template<class ObjectType>

size_t pat::PATObject< ObjectType >::genParticlesSize ( ) const

inline

Number of generator level particles stored as ref or embedded.

Definition at line 249 of file PATObject.h.

                                       {
             return genParticleEmbedded_.empty() ? genParticleRef_.size() : genParticleEmbedded_.size();
       }

template<class ObjectType >

const pat::CandKinResolution & pat::PATObject< ObjectType >::getKinResolution ( const std::string & label = "" ) const

Return the kinematic resolutions associated to this object, possibly specifying a label for it. If not present, it will throw an exception.

Definition at line 903 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, Exception, pat::PATObject< ObjectType >::kinResolutionLabels_, pat::PATObject< ObjectType >::kinResolutions_, diffTwoXMLs::label, and match().

                                                                                                    {
     const bool has_unlabelled = (kinResolutionLabels_.size()+1 == kinResolutions_.size());
     if (label.empty()) {
         if ( has_unlabelled ) {
             return kinResolutions_[0];
         } else {
             throw cms::Exception("Missing Data", "This object does not contain an un-labelled kinematic resolution");
         }
     } else {
         auto match = std::lower_bound(kinResolutionLabels_.cbegin(), kinResolutionLabels_.cend(), label);
         const auto dist = std::distance(kinResolutionLabels_.begin(),match);
         const size_t increment = ( has_unlabelled ? 1 : 0 );
         if ( match == kinResolutionLabels_.end() || *match != label ) {
             cms::Exception ex("Missing Data");
             ex << "This object does not contain a kinematic resolution with name '" << label << "'.\n";
             ex << "The known labels are: " ;
             for (std::vector<std::string>::const_iterator it = kinResolutionLabels_.cbegin(); it != kinResolutionLabels_.cend(); ++it) {
                 ex << "'" << *it << "' ";
             }
             ex << "\n";
             throw ex;
         } else {           
             return kinResolutions_[dist+increment];          
         }
     }
   }

template<class ObjectType >

bool pat::PATObject< ObjectType >::hasKinResolution ( const std::string & label = "" ) const

Check if the kinematic resolutions are stored into this object (possibly specifying a label for them)

Definition at line 931 of file PATObject.h.

References pat::PATObject< ObjectType >::kinResolutionLabels_, pat::PATObject< ObjectType >::kinResolutions_, diffTwoXMLs::label, and match().

                                                                            {
     if (label.empty()) {
         return (kinResolutionLabels_.size()+1 == kinResolutions_.size());
     } else {
         auto match = std::lower_bound(kinResolutionLabels_.cbegin(), kinResolutionLabels_.cend(), label);
         return ( match != kinResolutionLabels_.cend() && *match == label );
     }
   }

template<class ObjectType >

bool pat::PATObject< ObjectType >::hasOverlaps ( const std::string & label ) const

Returns true if there was at least one overlap for this test label.

Definition at line 736 of file PATObject.h.

References diffTwoXMLs::label, match(), and pat::PATObject< ObjectType >::overlapLabels_.

                                                                       {
         auto match = std::lower_bound(overlapLabels_.cbegin(), overlapLabels_.cend(), label);
         return ( match != overlapLabels_.end() && *match == label );
   }

template<class ObjectType>

bool pat::PATObject< ObjectType >::hasUserCand ( const std::string & key ) const

inline

Return true if there is a user-defined int with a given name.

Definition at line 364 of file PATObject.h.

                                                       {
         auto it = std::lower_bound(userCandLabels_.cbegin(), userCandLabels_.cend(), key);
         return ( it != userCandLabels_.cend() && *it == key );
       }

template<class ObjectType>

bool pat::PATObject< ObjectType >::hasUserData ( const std::string & key ) const

inline

Check if user data with a specific type is present.

Definition at line 286 of file PATObject.h.

Referenced by BPHUserData::getByRef().

                                                    {
           return (userDataObject_(key) != nullptr);
       }

template<class ObjectType>

bool pat::PATObject< ObjectType >::hasUserFloat ( const std::string & key ) const

inline

Return true if there is a user-defined float with a given name.

Definition at line 334 of file PATObject.h.

Referenced by BPHFittedBasicSelect::accept(), WenuPlots::analyze(), BPHHistoSpecificDecay::endJob(), and Jet.Jet::puMva().

                                                        {
         auto it = std::lower_bound(userFloatLabels_.cbegin(), userFloatLabels_.cend(), key); 
         return ( it != userFloatLabels_.cend() && *it == key );
       }

template<class ObjectType>

bool pat::PATObject< ObjectType >::hasUserFloat ( const char * key ) const

inline

a CINT-friendly interface

Definition at line 339 of file PATObject.h.

Referenced by pat::PATObject< reco::Muon >::hasUserFloat(), and Jet.Jet::puMva().

339 {return hasUserFloat( std::string(key) );}

AlCaHLTBitMon_QueryRunRegistry.string

string

Definition: AlCaHLTBitMon_QueryRunRegistry.py:255

pat::PATObject::hasUserFloat

bool hasUserFloat(const std::string &key) const

Return true if there is a user-defined float with a given name.

Definition: PATObject.h:334

crabWrapper.key

key

Definition: crabWrapper.py:17

template<class ObjectType>

bool pat::PATObject< ObjectType >::hasUserInt ( const std::string & key ) const

inline

Return true if there is a user-defined int with a given name.

Definition at line 351 of file PATObject.h.

Referenced by WenuPlots::analyze(), WenuPlots::PassPreselectionCriteria(), ZeePlots::PassPreselectionCriteria1(), and ZeePlots::PassPreselectionCriteria2().

                                                      {
         auto it = std::lower_bound(userIntLabels_.cbegin(), userIntLabels_.cend(), key);
         return ( it != userIntLabels_.cend() && *it == key );
       }

template<class ObjectType >

const reco::Candidate * pat::PATObject< ObjectType >::originalObject ( ) const

access to the original object; returns zero for null Ref and throws for unavailable collection

Definition at line 487 of file PATObject.h.

References Exception, edm::Ptr< T >::get(), edm::Ptr< T >::isAvailable(), edm::Ptr< T >::isNull(), edm::errors::ProductNotFound, and pat::PATObject< ObjectType >::refToOrig_.

Referenced by hitfit::JetTranslatorBase< AJet >::CheckEta(), and hitfit::JetTranslatorBase< AJet >::operator()().

                                                                                                 {
     if (refToOrig_.isNull()) {
       // this object was not produced from a reference, so no link to the
       // original object exists -> return a 0-pointer
       return 0;
     } else if (!refToOrig_.isAvailable()) {
       throw edm::Exception(edm::errors::ProductNotFound) << "The original collection from which this PAT object was made is not present any more in the event, hence you cannot access the originating object anymore.";
     } else {
       return refToOrig_.get();
     }
   }

template<class ObjectType >

const edm::Ptr< reco::Candidate > & pat::PATObject< ObjectType >::originalObjectRef ( ) const

reference to original object. Returns a null reference if not available

Definition at line 500 of file PATObject.h.

References pat::PATObject< ObjectType >::refToOrig_.

Referenced by heppy::CMGMuonCleanerBySegmentsAlgo::isSameMuon(), modules::MuonCleanerBySegmentsT< T >::isSameMuon(), TemplatedSecondaryVertexProducer< IPTI, VTX >::matchSubjets(), EGPfIsolationModifierFromValueMaps::modifyObject(), EGFull5x5ShowerShapeModifierFromValueMaps::modifyObject(), EGExtraInfoModifierFromValueMaps< MapType, OutputType >::modifyObject(), FindCorrectedSubjet::operator()(), SoftPFMuonTagInfoProducer::produce(), and EGExtraInfoModifierFromDB::setEvent().

500 { return refToOrig_; }

pat::PATObject::refToOrig_

edm::Ptr< reco::Candidate > refToOrig_

Definition: PATObject.h:421

template<class ObjectType>

const std::vector<std::string>& pat::PATObject< ObjectType >::overlapLabels ( ) const

inline

Returns the labels of the overlap tests that found at least one overlap.

Definition at line 273 of file PATObject.h.

273 { return overlapLabels_; }

pat::PATObject::overlapLabels_

std::vector< std::string > overlapLabels_

Overlapping test labels (only if there are any overlaps)

Definition: PATObject.h:437

template<class ObjectType >

const reco::CandidatePtrVector & pat::PATObject< ObjectType >::overlaps ( const std::string & label ) const

Return the list of overlaps for one label (can be empty) The original ordering of items is kept (usually it's by increasing deltaR from this item)

Definition at line 742 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, pat::pat_statics::EMPTY_CPV, diffTwoXMLs::label, match(), pat::PATObject< ObjectType >::overlapItems_, and pat::PATObject< ObjectType >::overlapLabels_.

Referenced by pat::PATObject< ObjectType >::setOverlaps().

                                                                                              {
         
         auto match = std::lower_bound(overlapLabels_.cbegin(), overlapLabels_.cend(), label);
         if( match == overlapLabels_.cend() || *match != label ) return pat_statics::EMPTY_CPV;
         return overlapItems_[std::distance(overlapLabels_.begin(),match)];
   }

template<class ObjectType>

double pat::PATObject< ObjectType >::resolE ( const std::string & label = "" ) const

inline

Resolution on energy, possibly with a label to specify which resolution to use.

Definition at line 390 of file PATObject.h.

390 { return getKinResolution(label).resolE(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::CandKinResolution::resolE

double resolE(const LorentzVector &p4) const

Resolution on energy, given the 4-momentum of the associated Candidate.

Definition: CandKinResolution.cc:50

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

template<class ObjectType>

double pat::PATObject< ObjectType >::resolEt ( const std::string & label = "" ) const

inline

Resolution on et, possibly with a label to specify which resolution to use.

Definition at line 393 of file PATObject.h.

393 { return getKinResolution(label).resolEt(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

pat::CandKinResolution::resolEt

double resolEt(const LorentzVector &p4) const

Resolution on et, given the 4-momentum of the associated Candidate.

Definition: CandKinResolution.cc:54

template<class ObjectType>

double pat::PATObject< ObjectType >::resolEta ( const std::string & label = "" ) const

inline

Resolution on eta, possibly with a label to specify which resolution to use.

Definition at line 381 of file PATObject.h.

381 { return getKinResolution(label).resolEta(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::CandKinResolution::resolEta

double resolEta(const LorentzVector &p4) const

Resolution on eta, given the 4-momentum of the associated Candidate.

Definition: CandKinResolution.cc:38

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

template<class ObjectType>

double pat::PATObject< ObjectType >::resolM ( const std::string & label = "" ) const

inline

Resolution on mass, possibly with a label to specify which resolution to use Note: this will be zero if a mass-constrained parametrization is used for this object

Definition at line 415 of file PATObject.h.

415 { return getKinResolution(label).resolM(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::CandKinResolution::resolM

double resolM(const LorentzVector &p4) const

Definition: CandKinResolution.cc:58

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

template<class ObjectType>

double pat::PATObject< ObjectType >::resolP ( const std::string & label = "" ) const

inline

Resolution on p, possibly with a label to specify which resolution to use.

Definition at line 396 of file PATObject.h.

396 { return getKinResolution(label).resolP(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

pat::CandKinResolution::resolP

double resolP(const LorentzVector &p4) const

Resolution on p, given the 4-momentum of the associated Candidate.

Definition: CandKinResolution.cc:62

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

template<class ObjectType>

double pat::PATObject< ObjectType >::resolPhi ( const std::string & label = "" ) const

inline

Resolution on phi, possibly with a label to specify which resolution to use.

Definition at line 387 of file PATObject.h.

387 { return getKinResolution(label).resolPhi(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

pat::CandKinResolution::resolPhi

double resolPhi(const LorentzVector &p4) const

Resolution on phi, given the 4-momentum of the associated Candidate.

Definition: CandKinResolution.cc:46

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

template<class ObjectType>

double pat::PATObject< ObjectType >::resolPInv ( const std::string & label = "" ) const

inline

Resolution on 1/p, possibly with a label to specify which resolution to use.

Definition at line 402 of file PATObject.h.

402 { return getKinResolution(label).resolPInv(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::CandKinResolution::resolPInv

double resolPInv(const LorentzVector &p4) const

Resolution on 1/p, given the 4-momentum of the associated Candidate.

Definition: CandKinResolution.cc:70

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

template<class ObjectType>

double pat::PATObject< ObjectType >::resolPt ( const std::string & label = "" ) const

inline

Resolution on pt, possibly with a label to specify which resolution to use.

Definition at line 399 of file PATObject.h.

399 { return getKinResolution(label).resolPt(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

pat::CandKinResolution::resolPt

double resolPt(const LorentzVector &p4) const

Resolution on pt, given the 4-momentum of the associated Candidate.

Definition: CandKinResolution.cc:66

template<class ObjectType>

double pat::PATObject< ObjectType >::resolPx ( const std::string & label = "" ) const

inline

Resolution on px, possibly with a label to specify which resolution to use.

Definition at line 405 of file PATObject.h.

405 { return getKinResolution(label).resolPx(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::CandKinResolution::resolPx

double resolPx(const LorentzVector &p4) const

Resolution on px, given the 4-momentum of the associated Candidate.

Definition: CandKinResolution.cc:74

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

template<class ObjectType>

double pat::PATObject< ObjectType >::resolPy ( const std::string & label = "" ) const

inline

Resolution on py, possibly with a label to specify which resolution to use.

Definition at line 408 of file PATObject.h.

408 { return getKinResolution(label).resolPy(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

pat::CandKinResolution::resolPy

double resolPy(const LorentzVector &p4) const

Resolution on py, given the 4-momentum of the associated Candidate.

Definition: CandKinResolution.cc:78

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

template<class ObjectType>

double pat::PATObject< ObjectType >::resolPz ( const std::string & label = "" ) const

inline

Resolution on pz, possibly with a label to specify which resolution to use.

Definition at line 411 of file PATObject.h.

411 { return getKinResolution(label).resolPz(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

pat::CandKinResolution::resolPz

double resolPz(const LorentzVector &p4) const

Resolution on pz, given the 4-momentum of the associated Candidate.

Definition: CandKinResolution.cc:82

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

template<class ObjectType>

double pat::PATObject< ObjectType >::resolTheta ( const std::string & label = "" ) const

inline

Resolution on theta, possibly with a label to specify which resolution to use.

Definition at line 384 of file PATObject.h.

384 { return getKinResolution(label).resolTheta(this->p4()); }

diffTwoXMLs.label

label

Definition: diffTwoXMLs.py:42

p4

double p4[4]

Definition: TauolaWrapper.h:92

pat::PATObject::getKinResolution

const pat::CandKinResolution & getKinResolution(const std::string &label="") const

Definition: PATObject.h:903

pat::CandKinResolution::resolTheta

double resolTheta(const LorentzVector &p4) const

Resolution on theta, given the 4-momentum of the associated Candidate.

Definition: CandKinResolution.cc:42

template<class ObjectType >

void pat::PATObject< ObjectType >::setEfficiency	(	const std::string &	name,
		const pat::LookupTableRecord &	value
	)

Store one efficiency in this item, in addition to the existing ones If an efficiency with the same name exists, the old value is replaced by this one Calling this method many times with names not sorted alphabetically will be slow

Definition at line 655 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, pat::PATObject< ObjectType >::efficiencyNames_, pat::PATObject< ObjectType >::efficiencyValues_, edm::eventsetup::heterocontainer::insert(), dataset::name, and relativeConstraints::value.

Referenced by pat::helper::EfficiencyLoader::setEfficiencies().

                                                                                                      {
     // look for the name, or to the place where we can insert it without violating the alphabetic order
     auto it = std::lower_bound(efficiencyNames_.begin(), efficiencyNames_.end(), name);
     const auto dist = std::distance(efficiencyNames_.begin(),it);
     if (it == efficiencyNames_.end()) { // insert at the end
         efficiencyNames_.push_back(name);
         efficiencyValues_.push_back(value);
     } else if (*it == name) {           // replace existing
         efficiencyValues_[dist] = value;
     } else {                            // insert in the middle :-(
         efficiencyNames_. insert(it, name);
         efficiencyValues_.insert( efficiencyValues_.begin() + dist, value );
     }
   }

template<class ObjectType >

void pat::PATObject< ObjectType >::setGenParticle ( const reco::GenParticle & particle )

Set the generator level particle from a particle not in the Event (embedding it, of course)

Definition at line 687 of file PATObject.h.

References pat::PATObject< ObjectType >::genParticleEmbedded_, and pat::PATObject< ObjectType >::genParticleRef_.

                                                                               {
       genParticleEmbedded_.clear();
       genParticleEmbedded_.push_back(particle);
       genParticleRef_.clear();
   }

template<class ObjectType >

void pat::PATObject< ObjectType >::setGenParticleRef	(	const reco::GenParticleRef &	ref,
		bool	embed = `false`
	)

Set the generator level particle reference.

Definition at line 671 of file PATObject.h.

References pat::PATObject< ObjectType >::embedGenParticle(), pat::PATObject< ObjectType >::genParticleEmbedded_, and pat::PATObject< ObjectType >::genParticleRef_.

Referenced by Onia2MuMuPAT::produce(), and pat::Lepton< reco::Muon >::setGenLepton().

                                                                                          {
           genParticleRef_ = std::vector<reco::GenParticleRef>(1,ref);
           genParticleEmbedded_.clear();
           if (embed) embedGenParticle();
   }

template<class ObjectType >

void pat::PATObject< ObjectType >::setKinResolution	(	const pat::CandKinResolution &	resol,
		const std::string &	label = `""`
	)

Add a kinematic resolution to this object (possibly with a label)

Definition at line 941 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, pat::PATObject< ObjectType >::kinResolutionLabels_, pat::PATObject< ObjectType >::kinResolutions_, diffTwoXMLs::label, and match().

Referenced by pat::helper::KinResolutionsLoader::setResolutions().

                                                                                                         {
     const bool has_unlabelled = (kinResolutionLabels_.size()+1 == kinResolutions_.size());
     if (label.empty()) {
         if (has_unlabelled) {
             // There is already an un-labelled object. Replace it
             kinResolutions_[0] = resol;
         } else {
             // Insert. Note that the un-labelled is always the first, so we need to insert before begin()
             // (for an empty vector, this should not cost more than push_back)
             kinResolutions_.insert(kinResolutions_.begin(), resol);
         }
     } else {
         auto match = std::lower_bound(kinResolutionLabels_.begin(), kinResolutionLabels_.end(), label);
         const auto dist = std::distance(kinResolutionLabels_.begin(),match);
         const size_t increment = ( has_unlabelled ? 1 : 0 );
         if ( match != kinResolutionLabels_.end() && *match == label ) {
             // Existing object: replace
             kinResolutions_[dist+increment] = resol;
         } else {
             kinResolutionLabels_.insert(match,label);
             kinResolutions_.insert(kinResolutions_.begin()+dist+increment,resol);
         }
     }
   }

template<class ObjectType >

void pat::PATObject< ObjectType >::setOverlaps	(	const std::string &	label,
		const reco::CandidatePtrVector &	overlaps
	)

Sets the list of overlapping items for one label Note that adding an empty PtrVector has no effect at all Items within the list should already be sorted appropriately (this method won't sort them)

Definition at line 750 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, diffTwoXMLs::label, match(), pat::PATObject< ObjectType >::overlapItems_, pat::PATObject< ObjectType >::overlapLabels_, and pat::PATObject< ObjectType >::overlaps().

                                                                                                          {
       
         auto match = std::lower_bound(overlapLabels_.begin(), overlapLabels_.end(), label);
         const auto dist = std::distance(overlapLabels_.begin(),match);
         if ( match == overlapLabels_.end() || *match != label ) {
           overlapLabels_.insert(match,label);
           overlapItems_.insert(overlapItems_.begin()+dist,overlaps);
         } else {
           overlapItems_[dist] = overlaps;
         }        
   }

template<class ObjectType >

const TriggerObjectStandAlone * pat::PATObject< ObjectType >::triggerObjectMatch ( const size_t idx = 0 ) const

get one matched trigger object by index

Definition at line 503 of file PATObject.h.

References edm::Ref< C, T, F >::get(), edm::Ref< C, T, F >::isNonnull(), findQualityFiles::size, pat::PATObject< ObjectType >::triggerObjectMatches(), and pat::PATObject< ObjectType >::triggerObjectMatchesEmbedded_.

                                                                                                     {
     if ( idx >= triggerObjectMatches().size() ) return 0;
     TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, idx );
     return ref.isNonnull() ? ref.get() : 0;
   }

template<class ObjectType >

const TriggerObjectStandAlone * pat::PATObject< ObjectType >::triggerObjectMatchByAlgorithm	(	const std::string &	nameAlgorithm,
		const bool	algoCondAccepted = `true`,
		const size_t	idx = `0`
	)		const

get one matched L1 object used in a succeeding object combination of a condition in a certain L1 (physics) algorithm by index; if 'algoCondAccepted' is set to 'true' (default), only objects used in succeeding conditions of succeeding algorithms are considered ("firing" objects)

Definition at line 581 of file PATObject.h.

References pat::TriggerObjectStandAlone::hasAlgorithmName(), mps_fire::i, edm::Ref< C, T, F >::isNonnull(), pat::PATObject< ObjectType >::triggerObjectMatch(), pat::PATObject< ObjectType >::triggerObjectMatches(), and pat::PATObject< ObjectType >::triggerObjectMatchesEmbedded_.

                                                                                                                                                                              {
     std::vector< size_t > refs;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasAlgorithmName( nameAlgorithm, algoCondAccepted ) ) refs.push_back( i );
     }
     if ( idx >= refs.size() ) return 0;
     TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
     return ref.isNonnull() ? ref.get() : 0;
   }

template<class ObjectType>

const TriggerObjectStandAlone* pat::PATObject< ObjectType >::triggerObjectMatchByAlgorithm	(	const char *	nameAlgorithm,
		const bool	algoCondAccepted = `true`,
		const size_t	idx = `0`
	)		const

inline

Definition at line 144 of file PATObject.h.

                                                                                                                                                                   {
         return triggerObjectMatchByAlgorithm( std::string( nameAlgorithm ), algoCondAccepted, idx );
       };

template<class ObjectType>

const TriggerObjectStandAlone* pat::PATObject< ObjectType >::triggerObjectMatchByAlgorithm	(	const std::string &	nameAlgorithm,
		const unsigned	algoCondAccepted,
		const size_t	idx = `0`
	)		const

inline

Definition at line 148 of file PATObject.h.

                                                                                                                                                                     {
         return triggerObjectMatchByAlgorithm( nameAlgorithm, bool( algoCondAccepted ), idx );
       };

template<class ObjectType>

const TriggerObjectStandAlone* pat::PATObject< ObjectType >::triggerObjectMatchByAlgorithm	(	const char *	nameAlgorithm,
		const unsigned	algoCondAccepted,
		const size_t	idx = `0`
	)		const

inline

Definition at line 152 of file PATObject.h.

                                                                                                                                                                {
         return triggerObjectMatchByAlgorithm( std::string( nameAlgorithm ), bool( algoCondAccepted ), idx );
       };

template<class ObjectType >

const TriggerObjectStandAlone * pat::PATObject< ObjectType >::triggerObjectMatchByCollection	(	const std::string &	coll,
		const size_t	idx = `0`
	)		const

get one matched trigger object from a certain collection by index

Definition at line 539 of file PATObject.h.

References pat::TriggerObjectStandAlone::hasCollection(), mps_fire::i, edm::Ref< C, T, F >::isNonnull(), pat::PATObject< ObjectType >::triggerObjectMatch(), pat::PATObject< ObjectType >::triggerObjectMatches(), and pat::PATObject< ObjectType >::triggerObjectMatchesEmbedded_.

                                                                                                                                         {
     std::vector< size_t > refs;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasCollection( coll ) ) {
         refs.push_back( i );
       }
     }
     if ( idx >= refs.size() ) return 0;
     TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
     return ref.isNonnull() ? ref.get() : 0;
   }

template<class ObjectType>

const TriggerObjectStandAlone* pat::PATObject< ObjectType >::triggerObjectMatchByCollection	(	const char *	coll,
		const size_t	idx = `0`
	)		const

inline

Definition at line 108 of file PATObject.h.

                                                                                                                       {
         return triggerObjectMatchByCollection( std::string( coll ), idx );
       };

template<class ObjectType >

const TriggerObjectStandAlone * pat::PATObject< ObjectType >::triggerObjectMatchByCondition	(	const std::string &	nameCondition,
		const size_t	idx = `0`
	)		const

get one matched L1 object used in a succeeding object combination of a certain L1 condition by index

Definition at line 561 of file PATObject.h.

References pat::TriggerObjectStandAlone::hasConditionName(), mps_fire::i, edm::Ref< C, T, F >::isNonnull(), pat::PATObject< ObjectType >::triggerObjectMatch(), pat::PATObject< ObjectType >::triggerObjectMatches(), and pat::PATObject< ObjectType >::triggerObjectMatchesEmbedded_.

                                                                                                                                                 {
     std::vector< size_t > refs;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasConditionName( nameCondition ) ) refs.push_back( i );
     }
     if ( idx >= refs.size() ) return 0;
     TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
     return ref.isNonnull() ? ref.get() : 0;
   }

template<class ObjectType>

const TriggerObjectStandAlone* pat::PATObject< ObjectType >::triggerObjectMatchByCondition	(	const char *	nameCondition,
		const size_t	idx = `0`
	)		const

inline

Definition at line 120 of file PATObject.h.

                                                                                                                               {
         return triggerObjectMatchByCondition( std::string( nameCondition ), idx );
       };

template<class ObjectType >

const TriggerObjectStandAlone * pat::PATObject< ObjectType >::triggerObjectMatchByFilter	(	const std::string &	labelFilter,
		const size_t	idx = `0`
	)		const

get one matched HLT object used in a certain HLT filter by index

Definition at line 601 of file PATObject.h.

References pat::TriggerObjectStandAlone::hasFilterLabel(), mps_fire::i, edm::Ref< C, T, F >::isNonnull(), pat::PATObject< ObjectType >::triggerObjectMatch(), pat::PATObject< ObjectType >::triggerObjectMatches(), and pat::PATObject< ObjectType >::triggerObjectMatchesEmbedded_.

                                                                                                                                            {
     std::vector< size_t > refs;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasFilterLabel( labelFilter ) ) refs.push_back( i );
     }
     if ( idx >= refs.size() ) return 0;
     TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
     return ref.isNonnull() ? ref.get() : 0;
   }

template<class ObjectType>

const TriggerObjectStandAlone* pat::PATObject< ObjectType >::triggerObjectMatchByFilter	(	const char *	labelFilter,
		const size_t	idx = `0`
	)		const

inline

Definition at line 164 of file PATObject.h.

                                                                                                                          {
         return triggerObjectMatchByFilter( std::string( labelFilter ), idx );
       };

template<class ObjectType>

const TriggerObjectStandAlone* pat::PATObject< ObjectType >::triggerObjectMatchByFilterID	(	const unsigned	triggerObjectType,
		const size_t	idx = `0`
	)		const

inline

Definition at line 96 of file PATObject.h.

                                                                                                                                    {
         return triggerObjectMatchByType( trigger::TriggerObjectType( triggerObjectType ), idx );
       };

template<class ObjectType >

const TriggerObjectStandAlone * pat::PATObject< ObjectType >::triggerObjectMatchByPath	(	const std::string &	namePath,
		const bool	pathLastFilterAccepted = `false`,
		const bool	pathL3FilterAccepted = `true`,
		const size_t	idx = `0`
	)		const

get one matched HLT object used in a certain HLT path by index; if 'pathLastFilterAccepted' is set to 'true' (default), only objects used in the final filter of a succeeding path are considered ("firing" objects, old style only valid for single object triggers); if 'pathL3FilterAccepted' is set to 'true' (default), only objects used in L3 filters (identified by the "saveTags" parameter being 'true') of a succeeding path are considered ("firing" objects also valid for x-triggers)

Definition at line 621 of file PATObject.h.

References pat::TriggerObjectStandAlone::hasPathName(), mps_fire::i, edm::Ref< C, T, F >::isNonnull(), pat::PATObject< ObjectType >::triggerObjectMatch(), pat::PATObject< ObjectType >::triggerObjectMatches(), and pat::PATObject< ObjectType >::triggerObjectMatchesEmbedded_.

                                                                                                                                                                                                           {
     std::vector< size_t > refs;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasPathName( namePath, pathLastFilterAccepted, pathL3FilterAccepted ) ) refs.push_back( i );
     }
     if ( idx >= refs.size() ) return 0;
     TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
     return ref.isNonnull() ? ref.get() : 0;
   }

template<class ObjectType>

const TriggerObjectStandAlone* pat::PATObject< ObjectType >::triggerObjectMatchByPath	(	const char *	namePath,
		const bool	pathLastFilterAccepted = `false`,
		const bool	pathL3FilterAccepted = `true`,
		const size_t	idx = `0`
	)		const

inline

Definition at line 192 of file PATObject.h.

                                                                                                                                                                                                        {
         return triggerObjectMatchByPath( std::string( namePath ), pathLastFilterAccepted, pathL3FilterAccepted, idx );
       };

template<class ObjectType>

const TriggerObjectStandAlone* pat::PATObject< ObjectType >::triggerObjectMatchByPath	(	const std::string &	namePath,
		const unsigned	pathLastFilterAccepted,
		const unsigned	pathL3FilterAccepted = `1`,
		const size_t	idx = `0`
	)		const

inline

Definition at line 196 of file PATObject.h.

                                                                                                                                                                                                          {
         return triggerObjectMatchByPath( namePath, bool( pathLastFilterAccepted ), bool( pathL3FilterAccepted ), idx );
       };

template<class ObjectType>

const TriggerObjectStandAlone* pat::PATObject< ObjectType >::triggerObjectMatchByPath	(	const char *	namePath,
		const unsigned	pathLastFilterAccepted,
		const unsigned	pathL3FilterAccepted = `1`,
		const size_t	idx = `0`
	)		const

inline

Definition at line 200 of file PATObject.h.

                                                                                                                                                                                                     {
         return triggerObjectMatchByPath( std::string( namePath ), bool( pathLastFilterAccepted ), bool( pathL3FilterAccepted ), idx );
       };

template<class ObjectType >

const TriggerObjectStandAlone * pat::PATObject< ObjectType >::triggerObjectMatchByType	(	const trigger::TriggerObjectType	triggerObjectType,
		const size_t	idx = `0`
	)		const

get one matched trigger object of a certain type by index

Definition at line 519 of file PATObject.h.

References pat::TriggerObject::hasTriggerObjectType(), mps_fire::i, edm::Ref< C, T, F >::isNonnull(), pat::PATObject< ObjectType >::triggerObjectMatch(), pat::PATObject< ObjectType >::triggerObjectMatches(), and pat::PATObject< ObjectType >::triggerObjectMatchesEmbedded_.

                                                                                                                                                             {
     std::vector< size_t > refs;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasTriggerObjectType( triggerObjectType ) ) refs.push_back( i );
     }
     if ( idx >= refs.size() ) return 0;
     TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
     return ref.isNonnull() ? ref.get() : 0;
   }

template<class ObjectType>

const TriggerObjectStandAlone* pat::PATObject< ObjectType >::triggerObjectMatchByType	(	const unsigned	triggerObjectType,
		const size_t	idx = `0`
	)		const

inline

Definition at line 92 of file PATObject.h.

                                                                                                                                {
         return triggerObjectMatchByType( trigger::TriggerObjectType( triggerObjectType ), idx );
       };

template<class ObjectType>

const TriggerObjectStandAloneCollection& pat::PATObject< ObjectType >::triggerObjectMatches ( ) const

inline

get all matched trigger objects

access to embedded trigger matches: duplicated functions using 'char*' instead of 'std::string' are needed in order to work properly in CINT command lines; duplicated functions using 'unsigned' instead of 'bool' are needed in order to work properly in the cut string parser;

Definition at line 77 of file PATObject.h.

77 { return triggerObjectMatchesEmbedded_; };

pat::PATObject::triggerObjectMatchesEmbedded_

TriggerObjectStandAloneCollection triggerObjectMatchesEmbedded_

vector of trigger matches

Definition: PATObject.h:424

template<class ObjectType >

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByAlgorithm	(	const std::string &	nameAlgorithm,
		const bool	algoCondAccepted = `true`
	)		const

get all matched L1 objects used in a succeeding object combination of a condition in a certain L1 (physics) algorithm; if 'algoCondAccepted' is set to 'true' (default), only objects used in succeeding conditions of succeeding algorithms are considered ("firing" objects)

Definition at line 572 of file PATObject.h.

References pat::TriggerObjectStandAlone::hasAlgorithmName(), mps_fire::i, patRefSel_triggerMatching_cfi::matches, pat::PATObject< ObjectType >::triggerObjectMatch(), and pat::PATObject< ObjectType >::triggerObjectMatches().

                                                                                                                                                                      {
     TriggerObjectStandAloneCollection matches;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasAlgorithmName( nameAlgorithm, algoCondAccepted ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
     }
     return matches;
   }

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByAlgorithm	(	const char *	nameAlgorithm,
		const bool	algoCondAccepted = `true`
	)		const

inline

Definition at line 128 of file PATObject.h.

                                                                                                                                                       {
         return triggerObjectMatchesByAlgorithm( std::string( nameAlgorithm ), algoCondAccepted );
       };

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByAlgorithm	(	const std::string &	nameAlgorithm,
		const unsigned	algoCondAccepted
	)		const

inline

Definition at line 132 of file PATObject.h.

                                                                                                                                                         {
         return triggerObjectMatchesByAlgorithm( nameAlgorithm, bool( algoCondAccepted ) );
       };

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByAlgorithm	(	const char *	nameAlgorithm,
		const unsigned	algoCondAccepted
	)		const

inline

Definition at line 136 of file PATObject.h.

                                                                                                                                                    {
         return triggerObjectMatchesByAlgorithm( std::string( nameAlgorithm ), bool( algoCondAccepted ) );
       };

template<class ObjectType >

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByCollection ( const std::string & coll ) const

get all matched trigger objects from a certain collection

Definition at line 530 of file PATObject.h.

References pat::TriggerObjectStandAlone::hasCollection(), mps_fire::i, patRefSel_triggerMatching_cfi::matches, pat::PATObject< ObjectType >::triggerObjectMatch(), and pat::PATObject< ObjectType >::triggerObjectMatches().

                                                                                                                                 {
     TriggerObjectStandAloneCollection matches;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasCollection( coll ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
     }
     return matches;
   }

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByCollection ( const char * coll ) const

inline

Definition at line 102 of file PATObject.h.

                                                                                                           {
         return triggerObjectMatchesByCollection( std::string( coll ) );
       };

template<class ObjectType >

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByCondition ( const std::string & nameCondition ) const

get all matched L1 objects used in a succeeding object combination of a certain L1 condition

Definition at line 552 of file PATObject.h.

References pat::TriggerObjectStandAlone::hasConditionName(), mps_fire::i, patRefSel_triggerMatching_cfi::matches, pat::PATObject< ObjectType >::triggerObjectMatch(), and pat::PATObject< ObjectType >::triggerObjectMatches().

                                                                                                                                         {
     TriggerObjectStandAloneCollection matches;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasConditionName( nameCondition ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
     }
     return matches;
   }

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByCondition ( const char * nameCondition ) const

inline

Definition at line 114 of file PATObject.h.

                                                                                                                   {
         return triggerObjectMatchesByCondition( std::string( nameCondition ) );
       };

template<class ObjectType >

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByFilter ( const std::string & labelFilter ) const

get all matched HLT objects used in a certain HLT filter

Definition at line 592 of file PATObject.h.

References pat::TriggerObjectStandAlone::hasFilterLabel(), mps_fire::i, patRefSel_triggerMatching_cfi::matches, pat::PATObject< ObjectType >::triggerObjectMatch(), and pat::PATObject< ObjectType >::triggerObjectMatches().

                                                                                                                                    {
     TriggerObjectStandAloneCollection matches;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasFilterLabel( labelFilter ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
     }
     return matches;
   }

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByFilter ( const char * labelFilter ) const

inline

Definition at line 158 of file PATObject.h.

                                                                                                              {
         return triggerObjectMatchesByFilter( std::string( labelFilter ) );
       };

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByFilterID ( const unsigned triggerObjectType ) const

inline

Definition at line 87 of file PATObject.h.

                                                                                                                        {
         return triggerObjectMatchesByType( trigger::TriggerObjectType( triggerObjectType ) );
       };

template<class ObjectType >

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByPath	(	const std::string &	namePath,
		const bool	pathLastFilterAccepted = `false`,
		const bool	pathL3FilterAccepted = `true`
	)		const

get all matched HLT objects used in a certain HLT path; if 'pathLastFilterAccepted' is set to 'true' (default), only objects used in the final filter of a succeeding path are considered ("firing" objects old style only valid for single object triggers); if 'pathL3FilterAccepted' is set to 'true' (default), only objects used in L3 filters (identified by the "saveTags" parameter being 'true') of a succeeding path are considered ("firing" objects old style only valid for single object triggers)

Definition at line 612 of file PATObject.h.

References pat::TriggerObjectStandAlone::hasPathName(), mps_fire::i, patRefSel_triggerMatching_cfi::matches, pat::PATObject< ObjectType >::triggerObjectMatch(), and pat::PATObject< ObjectType >::triggerObjectMatches().

Referenced by testAnalyzer::analyze(), ZMuMu_vtxAnalyzer::analyze(), ZMuMu_efficiencyAnalyzer::analyze(), ZMuMu_MCanalyzer::analyze(), ZMuMu_Radiative_analyzer::analyze(), modules::ZHLTMatchFilter::operator()(), ZMuMuMuonUserData::produce(), and ZToLLEdmNtupleDumper::produce().

                                                                                                                                                                                                   {
     TriggerObjectStandAloneCollection matches;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasPathName( namePath, pathLastFilterAccepted, pathL3FilterAccepted ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
     }
     return matches;
   }

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByPath	(	const char *	namePath,
		const bool	pathLastFilterAccepted = `false`,
		const bool	pathL3FilterAccepted = `true`
	)		const

inline

Definition at line 174 of file PATObject.h.

                                                                                                                                                                                            {
         return triggerObjectMatchesByPath( std::string( namePath ), pathLastFilterAccepted, pathL3FilterAccepted );
       };

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByPath	(	const std::string &	namePath,
		const unsigned	pathLastFilterAccepted,
		const unsigned	pathL3FilterAccepted = `1`
	)		const

inline

Definition at line 178 of file PATObject.h.

                                                                                                                                                                                              {
         return triggerObjectMatchesByPath( namePath, bool( pathLastFilterAccepted ), bool( pathL3FilterAccepted ) );
       };

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByPath	(	const char *	namePath,
		const unsigned	pathLastFilterAccepted,
		const unsigned	pathL3FilterAccepted = `1`
	)		const

inline

Definition at line 182 of file PATObject.h.

                                                                                                                                                                                         {
         return triggerObjectMatchesByPath( std::string( namePath ), bool( pathLastFilterAccepted ), bool( pathL3FilterAccepted ) );
       };

template<class ObjectType >

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByType ( const trigger::TriggerObjectType triggerObjectType ) const

get all matched trigger objects of a certain type; trigger object types are defined in 'enum trigger::TriggerObjectType' (DataFormats/HLTReco/interface/TriggerTypeDefs.h)

Definition at line 510 of file PATObject.h.

References pat::TriggerObject::hasTriggerObjectType(), mps_fire::i, patRefSel_triggerMatching_cfi::matches, pat::PATObject< ObjectType >::triggerObjectMatch(), and pat::PATObject< ObjectType >::triggerObjectMatches().

                                                                                                                                                     {
     TriggerObjectStandAloneCollection matches;
     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
       if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasTriggerObjectType( triggerObjectType ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
     }
     return matches;
   }

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByType ( const unsigned triggerObjectType ) const

inline

Definition at line 83 of file PATObject.h.

                                                                                                                    {
         return triggerObjectMatchesByType( trigger::TriggerObjectType( triggerObjectType ) );
       };

template<class ObjectType>

void pat::PATObject< ObjectType >::unpackTriggerObjectPathNames ( const edm::TriggerNames & names )

inline

unpack path names of matched trigger objects (if they were packed before embedding, which is not normally the case)

Definition at line 206 of file PATObject.h.

                                                                         {
         for (std::vector<TriggerObjectStandAlone>::iterator it = triggerObjectMatchesEmbedded_.begin(), ed = triggerObjectMatchesEmbedded_.end(); it != ed; ++it) it->unpackPathNames(names);
       }

template<class ObjectType >

reco::CandidatePtr pat::PATObject< ObjectType >::userCand ( const std::string & key ) const

Get user-defined candidate ptr Note: it will a null pointer if the key is not found; you can check if the key exists with 'hasUserInt' method.

Definition at line 874 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, crabWrapper::key, pat::PATObject< ObjectType >::userCandLabels_, and pat::PATObject< ObjectType >::userCands_.

   {
     auto it = std::lower_bound(userCandLabels_.cbegin(), userCandLabels_.cend(), key);
     if (it != userCandLabels_.cend()) {
       return userCands_[std::distance(userCandLabels_.begin(),it)];
     }
     return reco::CandidatePtr();
   }

template<class ObjectType>

const std::vector<std::string>& pat::PATObject< ObjectType >::userCandNames ( ) const

inline

Get list of user-defined cand names.

Definition at line 362 of file PATObject.h.

362 { return userCandLabels_; }

pat::PATObject::userCandLabels_

std::vector< std::string > userCandLabels_

Definition: PATObject.h:451

template<class ObjectType>

template<typename T >

const T* pat::PATObject< ObjectType >::userData ( const std::string & key ) const

inline

Returns user-defined data. Returns NULL if the data is not present, or not of type T.

Definition at line 280 of file PATObject.h.

Referenced by BPHWriteSpecificDecay::fill(), and BPHUserData::getByRef().

                                                                           {
           const pat::UserData * data = userDataObject_(key);
           return (data != nullptr ? data->template get<T>() : nullptr);
 
       }

template<class ObjectType>

const void* pat::PATObject< ObjectType >::userDataBare ( const std::string & key ) const

inline

Get the data as a void *, for CINT usage. COMPLETELY UNSUPPORTED, USE ONLY FOR DEBUGGING

Definition at line 299 of file PATObject.h.

                                                             {
           const pat::UserData * data = userDataObject_(key);
           return (data != nullptr ? data->bareData() : nullptr);
       }

template<class ObjectType>

const std::vector<std::string>& pat::PATObject< ObjectType >::userDataNames ( ) const

inline

Get list of user data object names.

Definition at line 295 of file PATObject.h.

295 { return userDataLabels_; }

pat::PATObject::userDataLabels_

std::vector< std::string > userDataLabels_

User data object.

Definition: PATObject.h:442

template<class ObjectType >

const pat::UserData * pat::PATObject< ObjectType >::userDataObject_ ( const std::string & key ) const

private

Definition at line 763 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, crabWrapper::key, pat::PATObject< ObjectType >::userDataLabels_, and pat::PATObject< ObjectType >::userDataObjects_.

   {
     auto it = std::lower_bound(userDataLabels_.cbegin(),userDataLabels_.cend(),key);
     if ( it != userDataLabels_.cend() && *it == key) {
       return &userDataObjects_[std::distance(userDataLabels_.cbegin(),it)];
     }
     return nullptr;
   }

template<class ObjectType>

const std::string& pat::PATObject< ObjectType >::userDataObjectType ( const std::string & key ) const

inline

Get human-readable type of user data object, for debugging.

Definition at line 290 of file PATObject.h.

                                                                        {
           const pat::UserData * data = userDataObject_(key);
           return (data != nullptr ? data->typeName() : pat_statics::EMPTY_STR);
       };

template<class ObjectType >

float pat::PATObject< ObjectType >::userFloat ( const std::string & key ) const

Get user-defined float Note: throws if the key is not found; you can check if the key exists with 'hasUserFloat' method.

Definition at line 791 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, crabWrapper::key, pat::throwMissingLabel(), pat::PATObject< ObjectType >::userFloatLabels_, and pat::PATObject< ObjectType >::userFloats_.

Referenced by BPHFittedBasicSelect::accept(), ZeePlots::analyze(), WenuPlots::analyze(), PhoMVACut::operator()(), GsfEleMVACut::operator()(), PhoAnyPFIsoWithEAAndExpoScalingCut::operator()(), PhoAnyPFIsoWithEAAndExpoScalingEBCut::operator()(), PhoAnyPFIsoWithEAAndQuadScalingCut::operator()(), PhoAnyPFIsoWithEACut::operator()(), Jet.Jet::puMva(), MuScleFitMuonSelector::selectMuons(), PhoMVACut::value(), GsfEleMVACut::value(), PhoAnyPFIsoWithEACut::value(), PhoAnyPFIsoWithEAAndExpoScalingCut::value(), PhoAnyPFIsoWithEAAndQuadScalingCut::value(), and PhoAnyPFIsoWithEAAndExpoScalingEBCut::value().

   {
     auto it = std::lower_bound(userFloatLabels_.cbegin(),userFloatLabels_.cend(),key);
     if( it != userFloatLabels_.cend() && *it == key ) {
       return userFloats_[std::distance(userFloatLabels_.cbegin(),it)];
     }
     throwMissingLabel("UserFloat",key,userFloatLabels_);
     return std::numeric_limits<float>::quiet_NaN();
   }

template<class ObjectType>

float pat::PATObject< ObjectType >::userFloat ( const char * key ) const

inline

a CINT-friendly interface

Definition at line 327 of file PATObject.h.

Referenced by Jet.Jet::puMva(), and pat::PATObject< reco::Muon >::userFloat().

327 { return userFloat( std::string(key) ); }

AlCaHLTBitMon_QueryRunRegistry.string

string

Definition: AlCaHLTBitMon_QueryRunRegistry.py:255

crabWrapper.key

key

Definition: crabWrapper.py:17

pat::PATObject::userFloat

float userFloat(const std::string &key) const

Definition: PATObject.h:791

template<class ObjectType>

const std::vector<std::string>& pat::PATObject< ObjectType >::userFloatNames ( ) const

inline

Get list of user-defined float names.

Definition at line 332 of file PATObject.h.

332 { return userFloatLabels_; }

pat::PATObject::userFloatLabels_

std::vector< std::string > userFloatLabels_

Definition: PATObject.h:445

template<class ObjectType >

std::vector< float > pat::PATObject< ObjectType >::userFloatRange ( const std::string & key ) const

return a range of values corresponding to key

Definition at line 802 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, crabWrapper::key, mps_fire::result, pat::PATObject< ObjectType >::userFloatLabels_, and pat::PATObject< ObjectType >::userFloats_.

                                                                                      {
     auto range = std::equal_range(userFloatLabels_.cbegin(),userFloatLabels_.cend(),key);
     std::vector<float> result;
     result.reserve(std::distance(range.first,range.second));
     for( auto it = range.first; it != range.second; ++it ) {
       result.push_back(userFloats_[std::distance(userFloatLabels_.cbegin(),it)]);
     }
     return result;
   }

template<class ObjectType >

int pat::PATObject< ObjectType >::userInt ( const std::string & key ) const

Get user-defined int Note: throws if the key is not found; you can check if the key exists with 'hasUserInt' method.

Definition at line 833 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, crabWrapper::key, hpstanc_transforms::max, pat::throwMissingLabel(), pat::PATObject< ObjectType >::userIntLabels_, and pat::PATObject< ObjectType >::userInts_.

Referenced by WenuPlots::analyze(), GsfEleMVACut::operator()(), PhoMVACut::operator()(), WenuPlots::PassPreselectionCriteria(), ZeePlots::PassPreselectionCriteria1(), and ZeePlots::PassPreselectionCriteria2().

   {
     auto it = std::lower_bound(userIntLabels_.cbegin(), userIntLabels_.cend(), key);
     if ( it != userIntLabels_.cend() && *it == key ) {
       return userInts_[std::distance(userIntLabels_.cbegin(),it)];
     }
     throwMissingLabel("UserInt",key,userIntLabels_);
     return std::numeric_limits<int>::max();
   }

template<class ObjectType>

const std::vector<std::string>& pat::PATObject< ObjectType >::userIntNames ( ) const

inline

Get list of user-defined int names.

Definition at line 349 of file PATObject.h.

349 { return userIntLabels_; }

pat::PATObject::userIntLabels_

std::vector< std::string > userIntLabels_

Definition: PATObject.h:448

template<class ObjectType >

std::vector< int > pat::PATObject< ObjectType >::userIntRange ( const std::string & key ) const

returns a range of values corresponding to key

Definition at line 844 of file PATObject.h.

References SoftLeptonByDistance_cfi::distance, crabWrapper::key, mps_fire::result, pat::PATObject< ObjectType >::userIntLabels_, and pat::PATObject< ObjectType >::userInts_.

                                                                                 {
     auto range = std::equal_range(userIntLabels_.cbegin(),userIntLabels_.cend(),key);
     std::vector<int> result;
     result.reserve(std::distance(range.first,range.second));
     for( auto it = range.first; it != range.second; ++it ) {
       result.push_back(userInts_[std::distance(userIntLabels_.cbegin(),it)]);
     }
     return result;
   }