CMSSW Reference Manual

List of all members.


Public Types
typedef ObjectType	base_type
Public Member Functions
void	addGenParticleRef (const reco::GenParticleRef &ref)
	Add a generator level particle reference If there is already an embedded particle, this ref will be embedded too.
void	addTriggerMatch (const pat::TriggerPrimitive &aTrigPrim)
	add an old trigger match
void	addTriggerObjectMatch (const TriggerObjectStandAlone &trigObj)
	add a trigger match
template<typename T>
void	addUserData (const std::string &label, const T &data, bool transientOnly=false)
	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.
void	addUserDataFromPtr (const std::string &label, const edm::Ptr< pat::UserData > &data)
	Set user-defined data.
void	addUserFloat (const std::string &label, float data)
	Set user-defined float.
void	addUserInt (const std::string &label, int32_t data)
	Set user-defined int.
std::vector< std::pair < std::string, pat::LookupTableRecord > >	efficiencies () const
	Returns the efficiencies as <name,value> pairs (by value).
const pat::LookupTableRecord &	efficiency (const std::string &name) const
	Returns an efficiency given its name.
const std::vector< std::string > &	efficiencyNames () const
	Returns the list of the names of the stored efficiencies.
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()).
void	embedGenParticle ()
	Embed the generator level particle(s) in this PATObject Note that generator level particles can only be all embedded or all not embedded.
const reco::GenParticle *	genParticle (size_t idx=0) const
	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.
reco::GenParticleRef	genParticleById (int pdgId, int status) 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.
reco::GenParticleRef	genParticleRef (size_t idx=0) const
	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.
std::vector< reco::GenParticleRef >	genParticleRefs () const
	Return the list of generator level particles.
size_t	genParticlesSize () const
	Number of generator level particles stored as ref or embedded.
const pat::CandKinResolution &	getKinResolution (const std::string &label="") const
	Return the kinematic resolutions associated to this object, possibly specifying a label for it.
bool	hasKinResolution (const std::string &label="") const
	Check if the kinematic resolutions are stored into this object (possibly specifying a label for them).
bool	hasOverlaps (const std::string &label) const
	Returns true if there was at least one overlap for this test label.
bool	hasUserData (const std::string &key) const
	Check if user data with a specific type is present.
bool	hasUserFloat (const std::string &key) const
	Return true if there is a user-defined float with a given name.
bool	hasUserInt (const std::string &key) const
	Return true if there is a user-defined int with a given name.
const reco::Candidate *	originalObject () const
	access to the original object; returns zero for null Ref and throws for unavailable collection
const edm::Ptr< reco::Candidate > &	originalObjectRef () const
	reference to original object. Returns a null reference if not available
const std::vector< std::string > &	overlapLabels () const
	Returns the labels of the overlap tests that found at least one overlap.
const reco::CandidatePtrVector &	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).
	PATObject (const edm::Ptr< ObjectType > &ref)
	constructor from reference
	PATObject (const edm::RefToBase< ObjectType > &ref)
	constructor from reference
	PATObject (const ObjectType &obj)
	constructor from a base object (leaves invalid reference to original object!)
	PATObject ()
	default constructor
double	resolE (const std::string &label="") const
	Resolution on energy, possibly with a label to specify which resolution to use.
double	resolEt (const std::string &label="") const
	Resolution on et, possibly with a label to specify which resolution to use.
double	resolEta (const std::string &label="") const
	Resolution on eta, possibly with a label to specify which resolution to use.
double	resolM (const std::string &label="") const
	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.
double	resolP (const std::string &label="") const
	Resolution on p, possibly with a label to specify which resolution to use.
double	resolPhi (const std::string &label="") const
	Resolution on phi, possibly with a label to specify which resolution to use.
double	resolPInv (const std::string &label="") const
	Resolution on 1/p, possibly with a label to specify which resolution to use.
double	resolPt (const std::string &label="") const
	Resolution on pt, possibly with a label to specify which resolution to use.
double	resolPx (const std::string &label="") const
	Resolution on px, possibly with a label to specify which resolution to use.
double	resolPy (const std::string &label="") const
	Resolution on py, possibly with a label to specify which resolution to use.
double	resolPz (const std::string &label="") const
	Resolution on pz, possibly with a label to specify which resolution to use.
double	resolTheta (const std::string &label="") const
	Resolution on theta, possibly with a label to specify which resolution to use.
void	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.
void	setGenParticle (const reco::GenParticle &particle)
	Set the generator level particle from a particle not in the Event (embedding it, of course).
void	setGenParticleRef (const reco::GenParticleRef &ref, bool embed=false)
	Set the generator level particle reference.
void	setKinResolution (const pat::CandKinResolution &resol, const std::string &label="")
	Add a kinematic resolution to this object (possibly with a label).
void	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).
const std::vector < TriggerPrimitive > &	triggerMatches () const
	old trigger matches
const std::vector < TriggerPrimitive >	triggerMatchesByFilter (const std::string &aFilt) const
const TriggerObjectStandAloneCollection &	triggerObjectMatches () const
	embedded trigger matches
const TriggerObjectStandAloneCollection	triggerObjectMatchesByCollection (const std::string &coll) const
const TriggerObjectStandAloneCollection	triggerObjectMatchesByFilter (const std::string &labelFilter) const
const TriggerObjectStandAloneCollection	triggerObjectMatchesByFilterID (const unsigned id) const
const TriggerObjectStandAloneCollection	triggerObjectMatchesByPath (const std::string &namePath) const
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.
const void *	userDataBare (const std::string &key) const
	Get the data as a void *, for CINT usage.
const std::vector< std::string > &	userDataNames () const
	Get list of user data object names.
const std::string &	userDataObjectType (const std::string &key) const
	Get human-readable type of user data object, for debugging.
float	userFloat (const std::string &key) const
	Get user-defined float Note: it will return 0.0 if the key is not found; you can check if the key exists with 'hasUserFloat' method.
const std::vector< std::string > &	userFloatNames () const
	Get list of user-defined float names.
int32_t	userInt (const std::string &key) const
	Get user-defined int Note: it will return 0 if the key is not found; you can check if the key exists with 'hasUserInt' method.
const std::vector< std::string > &	userIntNames () const
	Get list of user-defined int names.
virtual	~PATObject ()
	destructor
Protected Attributes
std::vector< std::string >	efficiencyNames_
	vector of the efficiencies (names)
std::vector < pat::LookupTableRecord >	efficiencyValues_
	vector of the efficiencies (values)
std::vector< reco::GenParticle >	genParticleEmbedded_
	vector to hold an embedded generator level particle
std::vector< reco::GenParticleRef >	genParticleRef_
	Reference to a generator level particle.
std::vector< std::string >	kinResolutionLabels_
	Labels for the kinematic resolutions.
std::vector < pat::CandKinResolution >	kinResolutions_
	Kinematic resolutions.
std::vector < reco::CandidatePtrVector >	overlapItems_
	Overlapping items (sorted by distance).
std::vector< std::string >	overlapLabels_
	Overlapping test labels (only if there are any overlaps).
edm::Ptr< reco::Candidate >	refToOrig_
std::vector < pat::TriggerPrimitive >	triggerMatches_
	vector of old trigger matches
TriggerObjectStandAloneCollection	triggerObjectMatchesEmbedded_
	vector of trigger matches
std::vector< std::string >	userDataLabels_
	User data object.
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 >

Member Typedef Documentation

template<class ObjectType>

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

Definition at line 46 of file PATObject.h.

Constructor & Destructor Documentation

template<class ObjectType>

pat::PATObject< ObjectType >::PATObject ( ) [inline]

default constructor

Definition at line 301 of file PATObject.h.

00301                                                                {
00302   }

template<class ObjectType>

pat::PATObject< ObjectType >::PATObject ( const ObjectType & obj ) [inline]

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

Definition at line 304 of file PATObject.h.

00304                                                                                      :
00305     ObjectType(obj),
00306     refToOrig_() {
00307   }

template<class ObjectType>

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

constructor from reference

Definition at line 309 of file PATObject.h.

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

template<class ObjectType>

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

constructor from reference

Definition at line 316 of file PATObject.h.

00316                                                                                              :
00317     ObjectType(*ref),
00318     refToOrig_(ref) {
00319   }

template<class ObjectType>

virtual pat::PATObject< ObjectType >::~PATObject ( ) [inline, virtual]

destructor

Definition at line 57 of file PATObject.h.

00057 {}

Member Function Documentation

template<class ObjectType>

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

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

Definition at line 444 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::PATMuonProducer::fillMuon(), pat::PATPhotonProducer::produce(), pat::PATTauProducer::produce(), pat::PATGenericParticleProducer::produce(), and pat::PATPFParticleProducer::produce().

00444                                                                              {
00445       if (!genParticleEmbedded_.empty()) { // we're embedding
00446           if (ref.isNonnull()) genParticleEmbedded_.push_back(*ref);
00447       } else {
00448           genParticleRef_.push_back(ref);
00449       }
00450   }

template<class ObjectType>

void pat::PATObject< ObjectType >::addTriggerMatch ( const pat::TriggerPrimitive & aTrigPrim ) [inline]

add an old trigger match

Definition at line 350 of file PATObject.h.

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

Referenced by pat::PATElectronProducer::FillElectron(), pat::PATMuonProducer::fillMuon(), pat::PATJetProducer::produce(), pat::PATMETProducer::produce(), pat::PATPhotonProducer::produce(), pat::PATTauProducer::produce(), and pat::PATGenericParticleProducer::produce().

00350                                                                                    {
00351     triggerMatches_.push_back(aTrigPrim);
00352   }

template<class ObjectType>

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

add a trigger match

Definition at line 394 of file PATObject.h.

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

00394                                                                                              {
00395     triggerObjectMatchesEmbedded_.push_back( trigObj );
00396   }

template<class ObjectType>

template<typename T>

void pat::PATObject< ObjectType >::addUserData	(	const std::string &	label,
		const T &	data,
		bool	transientOnly = `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 172 of file PATObject.h.

00172                                                                                             {
00173           userDataLabels_.push_back(label);
00174           userDataObjects_.push_back(pat::UserData::make<T>(data, transientOnly));
00175       }

template<class ObjectType>

void pat::PATObject< ObjectType >::addUserDataFromPtr	(	const std::string &	label,
		const edm::Ptr< pat::UserData > &	data
	)			`[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 179 of file PATObject.h.

00179                                                                                            {
00180           userDataLabels_.push_back(label);
00181           userDataObjects_.push_back(data->clone());
00182       }

template<class ObjectType>

void pat::PATObject< ObjectType >::addUserFloat	(	const std::string &	label,
		float	data
	)			`[inline]`

Set user-defined float.

Definition at line 535 of file PATObject.h.

References pat::PATObject< ObjectType >::userFloatLabels_, and pat::PATObject< ObjectType >::userFloats_.

00537   {
00538     userFloatLabels_.push_back(label);
00539     userFloats_.push_back( data );
00540   }

template<class ObjectType>

void pat::PATObject< ObjectType >::addUserInt	(	const std::string &	label,
		int32_t	data
	)

Set user-defined int.

template<class ObjectType>

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

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

Definition at line 411 of file PATObject.h.

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

00411                                             {
00412     std::vector<std::pair<std::string,pat::LookupTableRecord> > ret;
00413     std::vector<std::string>::const_iterator itn = efficiencyNames_.begin(), edn = efficiencyNames_.end();
00414     std::vector<pat::LookupTableRecord>::const_iterator itv = efficiencyValues_.begin();
00415     for ( ; itn != edn; ++itn, ++itv) {
00416         ret.push_back( std::pair<std::string,pat::LookupTableRecord>(*itn, *itv) );
00417     }
00418     return ret;
00419   }

template<class ObjectType>

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

Returns an efficiency given its name.

Definition at line 400 of file PATObject.h.

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

00400                                                                {
00401     // find the name in the (sorted) list of names
00402     std::vector<std::string>::const_iterator it = std::lower_bound(efficiencyNames_.begin(), efficiencyNames_.end(), name);
00403     if ((it == efficiencyNames_.end()) || (*it != name)) {
00404         throw cms::Exception("Invalid Label") << "There is no efficiency with name '" << name << "' in this PAT Object\n";
00405     }
00406     return efficiencyValues_[it - efficiencyNames_.begin()];
00407   }

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 85 of file PATObject.h.

00085 { return efficiencyNames_; }

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 87 of file PATObject.h.

00087 { return efficiencyValues_; }

template<class ObjectType>

void pat::PATObject< ObjectType >::embedGenParticle ( ) [inline]

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 460 of file PATObject.h.

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

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

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 106 of file PATObject.h.

Referenced by pat::Jet::genParton(), and pat::Photon::genPhoton().

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

template<class ObjectType>

reco::GenParticleRef pat::PATObject< ObjectType >::genParticleById	(	int	pdgId,
		int	status
	)			const `[inline]`

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.

Definition at line 479 of file PATObject.h.

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

00479                                                                                        {
00480         // get a vector, avoiding an unneeded copy if there is no embedding
00481         const std::vector<reco::GenParticleRef> & vec = (genParticleEmbedded_.empty() ? genParticleRef_ : genParticleRefs());
00482         for (std::vector<reco::GenParticleRef>::const_iterator ref = vec.begin(), end = vec.end(); ref != end; ++ref) {
00483             if (ref->isNonnull() && ((*ref)->pdgId() == pdgId) && ((*ref)->status() == status)) return *ref;
00484         }
00485         return reco::GenParticleRef();
00486   }

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 95 of file PATObject.h.

Referenced by pat::PATObject< reco::Muon >::genParticle().

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

template<class ObjectType>

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

Return the list of generator level particles.

Note that the refs can be transient refs to embedded GenParticles

Definition at line 469 of file PATObject.h.

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

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

00469                                                                              {
00470         if (genParticleEmbedded_.empty()) return genParticleRef_;
00471         std::vector<reco::GenParticleRef> ret(genParticleEmbedded_.size());
00472         for (size_t i = 0, n = ret.size(); i < n; ++i) {
00473             ret[i] = reco::GenParticleRef(&genParticleEmbedded_, i);
00474         }
00475         return ret;
00476   }

template<class ObjectType>

size_t pat::PATObject< ObjectType >::genParticlesSize ( ) const [inline]

Number of generator level particles stored as ref or embedded.

Definition at line 111 of file PATObject.h.

Referenced by pat::PATObject< reco::Muon >::genParticleRef().

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

template<class ObjectType>

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

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 562 of file PATObject.h.

References Exception, find(), it, pat::PATObject< ObjectType >::kinResolutionLabels_, pat::PATObject< ObjectType >::kinResolutions_, and edm::match().

00562                                                                                                    {
00563     if (label.empty()) {
00564         if (kinResolutionLabels_.size()+1 == kinResolutions_.size()) {
00565             return kinResolutions_[0];
00566         } else {
00567             throw cms::Exception("Missing Data", "This object does not contain an un-labelled kinematic resolution");
00568         }
00569     } else {
00570         std::vector<std::string>::const_iterator match = std::find(kinResolutionLabels_.begin(), kinResolutionLabels_.end(), label);
00571         if (match == kinResolutionLabels_.end()) {
00572             cms::Exception ex("Missing Data");
00573             ex << "This object does not contain a kinematic resolution with name '" << label << "'.\n";
00574             ex << "The known labels are: " ;
00575             for (std::vector<std::string>::const_iterator it = kinResolutionLabels_.begin(); it != kinResolutionLabels_.end(); ++it) {
00576                 ex << "'" << *it << "' ";
00577             }
00578             ex << "\n";
00579             throw ex;
00580         } else {
00581             if (kinResolutionLabels_.size()+1 == kinResolutions_.size()) {
00582                 // skip un-labelled resolution
00583                 return kinResolutions_[match - kinResolutionLabels_.begin() + 1];
00584             } else {
00585                 // all are labelled, so this is the real index
00586                 return kinResolutions_[match - kinResolutionLabels_.begin()];
00587             }
00588         }
00589     }
00590   }

template<class ObjectType>

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

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

Definition at line 593 of file PATObject.h.

References find(), pat::PATObject< ObjectType >::kinResolutionLabels_, pat::PATObject< ObjectType >::kinResolutions_, and edm::match().

00593                                                                            {
00594     if (label.empty()) {
00595         return (kinResolutionLabels_.size()+1 == kinResolutions_.size());
00596     } else {
00597         std::vector<std::string>::const_iterator match = std::find(kinResolutionLabels_.begin(), kinResolutionLabels_.end(), label);
00598         return match != kinResolutionLabels_.end();
00599     }
00600   }

template<class ObjectType>

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

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

Definition at line 489 of file PATObject.h.

References find(), and pat::PATObject< ObjectType >::overlapLabels_.

00489                                                                       {
00490         return std::find(overlapLabels_.begin(), overlapLabels_.end(), label) != overlapLabels_.end();
00491   }

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

00148                                                    {
00149           return (userDataObject_(key) != 0);
00150       }

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 192 of file PATObject.h.

00192                                                        {
00193         return std::find(userFloatLabels_.begin(), userFloatLabels_.end(), key) != userFloatLabels_.end();
00194       }

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 203 of file PATObject.h.

00203                                                      {
00204         return std::find(userIntLabels_.begin(), userIntLabels_.end(), key) != userIntLabels_.end();
00205       }

template<class ObjectType>

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

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

Definition at line 322 of file PATObject.h.

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

00322                                                                                                 {
00323     if (refToOrig_.isNull()) {
00324       // this object was not produced from a reference, so no link to the
00325       // original object exists -> return a 0-pointer
00326       return 0;
00327     } else if (!refToOrig_.isAvailable()) {
00328       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.";
00329     } else {
00330       return refToOrig_.get();
00331     }
00332   }

template<class ObjectType>

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

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

Definition at line 335 of file PATObject.h.

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

00335 { return refToOrig_; }

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 135 of file PATObject.h.

00135 { return overlapLabels_; }

template<class ObjectType>

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

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 494 of file PATObject.h.

References evf::dqm::EMPTY, find(), edm::match(), pat::PATObject< ObjectType >::overlapItems_, and pat::PATObject< ObjectType >::overlapLabels_.

00494                                                                                              {
00495         static const reco::CandidatePtrVector EMPTY;
00496         std::vector<std::string>::const_iterator match = std::find(overlapLabels_.begin(), overlapLabels_.end(), label);
00497         if (match == overlapLabels_.end()) return EMPTY;
00498         return overlapItems_[match - overlapLabels_.begin()];
00499   }

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 228 of file PATObject.h.

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

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 231 of file PATObject.h.

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

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 219 of file PATObject.h.

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

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 253 of file PATObject.h.

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

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 234 of file PATObject.h.

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

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

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

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 240 of file PATObject.h.

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

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 237 of file PATObject.h.

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

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 243 of file PATObject.h.

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

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 246 of file PATObject.h.

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

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 249 of file PATObject.h.

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

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 222 of file PATObject.h.

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

template<class ObjectType>

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

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 422 of file PATObject.h.

References pat::PATObject< ObjectType >::efficiencyNames_, pat::PATObject< ObjectType >::efficiencyValues_, edm::eventsetup::heterocontainer::insert(), and it.

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

00422                                                                                                      {
00423     // look for the name, or to the place where we can insert it without violating the alphabetic order
00424     std::vector<std::string>::iterator it = std::lower_bound(efficiencyNames_.begin(), efficiencyNames_.end(), name);
00425     if (it == efficiencyNames_.end()) { // insert at the end
00426         efficiencyNames_.push_back(name);
00427         efficiencyValues_.push_back(value);
00428     } else if (*it == name) {           // replace existing
00429         efficiencyValues_[it - efficiencyNames_.begin()] = value;
00430     } else {                            // insert in the middle :-(
00431         efficiencyNames_. insert(it, name);
00432         efficiencyValues_.insert( efficiencyValues_.begin() + (it - efficiencyNames_.begin()), value );
00433     }
00434   }

template<class ObjectType>

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

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

Definition at line 453 of file PATObject.h.

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

00453                                                                               {
00454       genParticleEmbedded_.clear(); 
00455       genParticleEmbedded_.push_back(particle);
00456       genParticleRef_.clear();
00457   }

template<class ObjectType>

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

Set the generator level particle reference.

Definition at line 437 of file PATObject.h.

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

Referenced by pat::Jet::setGenParton(), and pat::Photon::setGenPhoton().

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

template<class ObjectType>

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

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

Definition at line 603 of file PATObject.h.

References find(), pat::PATObject< ObjectType >::kinResolutionLabels_, pat::PATObject< ObjectType >::kinResolutions_, and edm::match().

00603                                                                                                         {
00604     if (label.empty()) {
00605         if (kinResolutionLabels_.size()+1 == kinResolutions_.size()) {
00606             // There is already an un-labelled object. Replace it
00607             kinResolutions_[0] = resol;
00608         } else {
00609             // Insert. Note that the un-labelled is always the first, so we need to insert before begin()
00610             // (for an empty vector, this should not cost more than push_back)
00611             kinResolutions_.insert(kinResolutions_.begin(), resol);
00612         }
00613     } else {
00614         std::vector<std::string>::iterator match = std::find(kinResolutionLabels_.begin(), kinResolutionLabels_.end(), label);
00615         if (match != kinResolutionLabels_.end()) {
00616             // Existing object: replace
00617             if (kinResolutionLabels_.size()+1 == kinResolutions_.size()) {
00618                 kinResolutions_[(match - kinResolutionLabels_.begin())+1] = resol;
00619             } else {
00620                 kinResolutions_[(match - kinResolutionLabels_.begin())] = resol;
00621             }
00622         } else {
00623             kinResolutionLabels_.push_back(label);
00624             kinResolutions_.push_back(resol);
00625         }
00626     }
00627   }

template<class ObjectType>

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

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 502 of file PATObject.h.

References edm::PtrVectorBase::empty(), find(), edm::match(), pat::PATObject< ObjectType >::overlapItems_, and pat::PATObject< ObjectType >::overlapLabels_.

00502                                                                                                          {
00503         if (!overlaps.empty()) {
00504             std::vector<std::string>::const_iterator match = std::find(overlapLabels_.begin(), overlapLabels_.end(), label);
00505             if (match == overlapLabels_.end()) {
00506                 overlapLabels_.push_back(label);
00507                 overlapItems_.push_back(overlaps);
00508             } else {
00509                 overlapItems_[match - overlapLabels_.begin()] = overlaps;
00510             }
00511         }
00512   }

template<class ObjectType>

const std::vector< TriggerPrimitive > & pat::PATObject< ObjectType >::triggerMatches ( ) const [inline]

old trigger matches

Definition at line 338 of file PATObject.h.

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

00338 { return triggerMatches_; }

template<class ObjectType>

const std::vector< TriggerPrimitive > pat::PATObject< ObjectType >::triggerMatchesByFilter ( const std::string & aFilt ) const [inline]

Definition at line 341 of file PATObject.h.

References i, and pat::PATObject< ObjectType >::triggerMatches_.

00341                                                                                                                {
00342     std::vector<TriggerPrimitive> selectedMatches;
00343     for ( size_t i = 0; i < triggerMatches_.size(); i++ ) {
00344       if ( triggerMatches_.at(i).filterName() == aFilt ) selectedMatches.push_back(triggerMatches_.at(i));
00345     }
00346     return selectedMatches;
00347   }

template<class ObjectType>

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

embedded trigger matches

Definition at line 355 of file PATObject.h.

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

Referenced by pat::PATObject< ObjectType >::triggerObjectMatchesByCollection(), pat::PATObject< ObjectType >::triggerObjectMatchesByFilter(), pat::PATObject< ObjectType >::triggerObjectMatchesByFilterID(), and pat::PATObject< ObjectType >::triggerObjectMatchesByPath().

00355 { return triggerObjectMatchesEmbedded_; }

template<class ObjectType>

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

Definition at line 367 of file PATObject.h.

References asciidump::at, i, and pat::PATObject< ObjectType >::triggerObjectMatches().

00367                                                                                                                                 {
00368     TriggerObjectStandAloneCollection matches;
00369     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
00370       if ( triggerObjectMatches().at( i ).collection() == coll ) matches.push_back( triggerObjectMatches().at( i ) );
00371     }
00372     return matches;
00373   }

template<class ObjectType>

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

Definition at line 376 of file PATObject.h.

References asciidump::at, i, and pat::PATObject< ObjectType >::triggerObjectMatches().

00376                                                                                                                                    {
00377     TriggerObjectStandAloneCollection matches;
00378     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
00379       if ( triggerObjectMatches().at( i ).hasFilterLabel( labelFilter ) ) matches.push_back( triggerObjectMatches().at( i ) );
00380     }
00381     return matches;
00382   }

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByFilterID ( const unsigned id ) const [inline]

Definition at line 358 of file PATObject.h.

References asciidump::at, i, and pat::PATObject< ObjectType >::triggerObjectMatches().

00358                                                                                                                          {
00359     TriggerObjectStandAloneCollection matches;
00360     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
00361       if ( triggerObjectMatches().at( i ).hasFilterId( id ) ) matches.push_back( triggerObjectMatches().at( i ) );
00362     }
00363     return matches;
00364   }

template<class ObjectType>

const TriggerObjectStandAloneCollection pat::PATObject< ObjectType >::triggerObjectMatchesByPath ( const std::string & namePath ) const [inline]

Definition at line 385 of file PATObject.h.

References asciidump::at, i, and pat::PATObject< ObjectType >::triggerObjectMatches().

00385                                                                                                                               {
00386     TriggerObjectStandAloneCollection matches;
00387     for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
00388       if ( triggerObjectMatches().at( i ).hasPathName( namePath ) ) matches.push_back( triggerObjectMatches().at( i ) );
00389     }
00390     return matches;
00391   }

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

00142                                                                           {
00143           const pat::UserData * data = userDataObject_(key);
00144           return (data != 0 ? data->template get<T>() : 0);
00145           
00146       }

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 162 of file PATObject.h.

00162                                                             {
00163           const pat::UserData * data = userDataObject_(key);
00164           return (data != 0 ? data->bareData() : 0);
00165       }

template<class ObjectType>

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

Get list of user data object names.

Definition at line 158 of file PATObject.h.

00158 { return userDataLabels_; }

template<class ObjectType>

const pat::UserData * pat::PATObject< ObjectType >::userDataObject_ ( const std::string & key ) const [inline, private]

Definition at line 515 of file PATObject.h.

References find(), it, pat::PATObject< ObjectType >::userDataLabels_, and pat::PATObject< ObjectType >::userDataObjects_.

Referenced by pat::PATObject< reco::Muon >::hasUserData(), pat::PATObject< reco::Muon >::userData(), pat::PATObject< reco::Muon >::userDataBare(), and pat::PATObject< reco::Muon >::userDataObjectType().

00516   {
00517     std::vector<std::string>::const_iterator it = std::find(userDataLabels_.begin(), userDataLabels_.end(), key);
00518     if (it != userDataLabels_.end()) {
00519         return & userDataObjects_[it - userDataLabels_.begin()];
00520     }
00521     return 0;
00522   }

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 152 of file PATObject.h.

00152                                                                        { 
00153           static const std::string EMPTY("");
00154           const pat::UserData * data = userDataObject_(key);
00155           return (data != 0 ? data->typeName() : EMPTY);
00156       };

template<class ObjectType>

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

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

Definition at line 525 of file PATObject.h.

References find(), it, pat::PATObject< ObjectType >::userFloatLabels_, and pat::PATObject< ObjectType >::userFloats_.

00526   {
00527     std::vector<std::string>::const_iterator it = std::find(userFloatLabels_.begin(), userFloatLabels_.end(), key);
00528     if (it != userFloatLabels_.end()) {
00529         return userFloats_[it - userFloatLabels_.begin()];
00530     }
00531     return 0.0;
00532   }

template<class ObjectType>

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

Get list of user-defined float names.

Definition at line 190 of file PATObject.h.

00190 { return userFloatLabels_; }

template<class ObjectType>

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

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

Definition at line 544 of file PATObject.h.

References find(), it, pat::PATObject< ObjectType >::userIntLabels_, and pat::PATObject< ObjectType >::userInts_.

00545   {
00546     std::vector<std::string>::const_iterator it = std::find(userIntLabels_.begin(), userIntLabels_.end(), key);
00547     if (it != userIntLabels_.end()) {
00548         return userInts_[it - userIntLabels_.begin()];
00549     }
00550     return 0;
00551   }

template<class ObjectType>

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

Get list of user-defined int names.

Definition at line 201 of file PATObject.h.

00201 { return userIntLabels_; }

Member Data Documentation

template<class ObjectType>

std::vector<std::string> pat::PATObject< ObjectType >::efficiencyNames_ [protected]

vector of the efficiencies (names)

Definition at line 268 of file PATObject.h.

Referenced by pat::PATObject< ObjectType >::efficiencies(), pat::PATObject< ObjectType >::efficiency(), pat::PATObject< reco::Muon >::efficiencyNames(), and pat::PATObject< ObjectType >::setEfficiency().

template<class ObjectType>

std::vector<pat::LookupTableRecord> pat::PATObject< ObjectType >::efficiencyValues_ [protected]

vector of the efficiencies (values)

Definition at line 266 of file PATObject.h.

Referenced by pat::PATObject< ObjectType >::efficiencies(), pat::PATObject< ObjectType >::efficiency(), pat::PATObject< reco::Muon >::efficiencyValues(), and pat::PATObject< ObjectType >::setEfficiency().

template<class ObjectType>

std::vector<reco::GenParticle> pat::PATObject< ObjectType >::genParticleEmbedded_ [protected]

vector to hold an embedded generator level particle

Definition at line 273 of file PATObject.h.

Referenced by pat::PATObject< ObjectType >::addGenParticleRef(), pat::PATObject< ObjectType >::embedGenParticle(), pat::PATObject< ObjectType >::genParticleById(), pat::PATObject< reco::Muon >::genParticleRef(), pat::PATObject< ObjectType >::genParticleRefs(), pat::PATObject< reco::Muon >::genParticlesSize(), pat::PATObject< ObjectType >::setGenParticle(), and pat::PATObject< ObjectType >::setGenParticleRef().

template<class ObjectType>

std::vector<reco::GenParticleRef> pat::PATObject< ObjectType >::genParticleRef_ [protected]

Reference to a generator level particle.

Definition at line 271 of file PATObject.h.

template<class ObjectType>

std::vector<std::string> pat::PATObject< ObjectType >::kinResolutionLabels_ [protected]

Labels for the kinematic resolutions.

if (kinResolutions_.size() == kinResolutionLabels_.size()+1), then the first resolution has no label.

Definition at line 294 of file PATObject.h.

Referenced by pat::PATObject< ObjectType >::getKinResolution(), pat::PATObject< ObjectType >::hasKinResolution(), and pat::PATObject< ObjectType >::setKinResolution().

template<class ObjectType>

std::vector<pat::CandKinResolution> pat::PATObject< ObjectType >::kinResolutions_ [protected]

Kinematic resolutions.

Definition at line 291 of file PATObject.h.

Referenced by pat::PATObject< ObjectType >::getKinResolution(), pat::PATObject< ObjectType >::hasKinResolution(), and pat::PATObject< ObjectType >::setKinResolution().

template<class ObjectType>

std::vector<reco::CandidatePtrVector> pat::PATObject< ObjectType >::overlapItems_ [protected]

Overlapping items (sorted by distance).

Definition at line 278 of file PATObject.h.

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

pat::PATObject< ObjectType > Class Template Reference

Public Types

Public Member Functions

Protected Attributes

Private Member Functions

Detailed Description

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

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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