xAOD::MissingETAssociation_v1 Class Reference

MET association descriptor contains object links and corresponding parameters. More...

#include <MissingETAssociation_v1.h>

Inheritance diagram for xAOD::MissingETAssociation_v1:

Collaboration diagram for xAOD::MissingETAssociation_v1:

Classes
class	ConstVec
	Vector sum of constituents for subtractive overlap removal. More...

Public Types
using	TypelessConstAccessor = ConstAuxElement::TypelessConstAccessor
template<class T, class ALLOC = AuxAllocator_t<T>>
using	ConstAccessor = SG::ConstAccessor<T, ALLOC>
template<class T, class ALLOC = AuxAllocator_t<T>>
using	Accessor = SG::Accessor<T, ALLOC>
template<class T, class ALLOC = AuxAllocator_t<T>>
using	Decorator = SG::Decorator<T, ALLOC>

Public Member Functions
	MissingETAssociation_v1 (bool createStore=false)
	Default constructor.
	MissingETAssociation_v1 (const Jet *pjet, bool isMisc=false)
	Construct with a link to a Jet object.
	MissingETAssociation_v1 (const MissingETAssociation_v1 &assocDescr)
	Copy constructor.
MissingETAssociation_v1 &	operator= (const MissingETAssociation_v1 &assocDescr)
virtual	~MissingETAssociation_v1 ()
	Assignment operator.
size_t	findCalIndex (MissingETBase::Types::bitmask_t mask) const
size_t	findTrkIndex (MissingETBase::Types::bitmask_t mask) const
void	assign (const AuxElement &other, bool warnUnlocked=false)
	Assignment.
const SG::AuxVectorData *	container () const
	Return the container holding this element.
SG::AuxVectorData *	container ()
	Return the container holding this element.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::reference_type	auxdata (const std::string &name)
	Fetch an aux data variable, as a non-const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::reference_type	auxdata (const std::string &name, const std::string &clsname)
	Fetch an aux data variable, as a non-const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type	auxdata (const std::string &name) const
	Fetch an aux data variable, as a const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type	auxdata (const std::string &name, const std::string &clsname) const
	Fetch an aux data variable, as a const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type	auxdataConst (const std::string &name) const
	Fetch an aux data variable, as a const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type	auxdataConst (const std::string &name, const std::string &clsname) const
	Fetch an aux data variable, as a const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED bool	isAvailable (const std::string &name, const std::string &clsname="") const
	Check if an aux variable is available for reading.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED bool	isAvailableWritable (const std::string &name, const std::string &clsname="")
	Check if an aux variable is available for writing.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED bool	isAvailableWritableAsDecoration (const std::string &name, const std::string &clsname="") const
	Check if an aux variable is available for writing as a decoration.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Decorator< T, ALLOC >::reference_type	auxdecor (const std::string &name) const
	Fetch an aux decoration, as a non-const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Decorator< T, ALLOC >::reference_type	auxdecor (const std::string &name, const std::string &clsname) const
	Fetch an aux decoration, as a non-const reference.
void	makePrivateStore ()
	Create a new (empty) private store for this object.
template<class U1>
void	makePrivateStore (const U1 &other, bool warnUnlocked=false)
	Create a new private store for this object and copy aux data.
template<class U1>
void	makePrivateStore (const U1 *other, bool warnUnlocked=false)
	Create a new private store for this object and copy aux data.
void	releasePrivateStore ()
	Release and free any private store associated with this object.
void	setStore (const SG::IConstAuxStore *store)
	Set the store associated with this object.
void	setStore (SG::IAuxStore *store)
	Set the store associated with this object.
void	setStore (const DataLink< SG::IConstAuxStore > &store)
	Set the store associated with this object.
void	setConstStore (const SG::IConstAuxStore *store)
	Synonym for setStore with IConstAuxStore.
void	setNonConstStore (SG::IAuxStore *store)
	Synonym for setStore with IAuxStore.
bool	usingPrivateStore () const
	Test to see if this object is currently using a private store.
bool	usingStandaloneStore () const
	Test to see if this object is currently using a standalone store.
const SG::IConstAuxStore *	getConstStore () const
	Return the current store, as a const interface.
SG::IAuxStore *	getStore () const
	Return the current store, as a non-const interface.
void	clearCache ()
	Clear the cached aux data pointers.
const SG::auxid_set_t &	getAuxIDs () const
	Return a set of identifiers for existing data items for this object.
const SG::auxid_set_t &	getDecorIDs () const
	Return a set of identifiers for decorations for this object.
bool	hasStore () const
	Return true if this object has an associated store.
bool	hasNonConstStore () const
	Return true if this object has an associated non-const store.
bool	clearDecorations () const
	Clear all decorations.
bool	trackIndices () const
	Return true if index tracking is enabled for this object.
size_t	index () const
	Return the index of this element within its container.
Set reference jet
Base class destructor
bool	setRefJet (const Jet *pJet)
	Set reference jet by object pointer reference.
bool	setRefJet (const JetContainer *pJetCont, size_t pJetIdx)
	Set reference jet by container pointer and index reference.
Adding data to the MET association description
bool	addObject (const IParticle *pPart, const std::vector< const IParticle * > &constlist)
	Add object (particle) from pointer reference with individual constituent vectors.
Conventional and dedicated getter and setters
const std::vector< float > &	calpx () const
	Get the vector of \( P_{x} \).
float	calpx (const IParticle *pPart) const
	Get the vector \( P_{x} \) for a given object referenced by pointer.
float	calpx (size_t keyIdx) const
	Get the vector \( P_{x} \) for a given object referenced by index.
bool	setCalPx (const std::vector< float > &calpxvec)
	Set the vector of \( P_{x} \).
bool	setCalPx (size_t keyIdx, float calpx)
	Set calo constituent vector \( P_{x} \) for a given contributing object referenced by index.
const std::vector< float > &	calpy () const
	Get the vector of \( P_{y} \).
float	calpy (size_t keyIdx) const
	Get the vector \( P_{y} \) for a given object referenced by index.
bool	setCalPy (const std::vector< float > &calpyvec)
	Set the vector of \( P_{y} \).
bool	setCalPy (size_t keyIdx, float calpy)
	Set calo constituent vector \( P_{y} \) for a given contributing object referenced by index.
const std::vector< float > &	calpz () const
	Get the vector of \( P_{z} \).
float	calpz (size_t keyIdx) const
	Get the vector \( P_{z} \) for a given object referenced by index.
bool	setCalPz (const std::vector< float > &calpzvec)
	Set the vector of \( P_{z} \).
bool	setCalPz (size_t keyIdx, float calpz)
	Set calo constituent vector \( P_{z} \) for a given contributing object referenced by index.
const std::vector< float > &	cale () const
	Get the vector of \( E \).
float	cale (size_t keyIdx) const
	Get the vector \( E \) for a given object referenced by index.
bool	setCalE (const std::vector< float > &calevec)
	Set the vector of \( E \).
bool	setCalE (size_t keyIdx, float cale)
	Set calo constituent vector \( E \) for a given contributing object referenced by index.
const std::vector< float > &	calsumpt () const
	Get the vector of sumpt.
float	calsumpt (size_t keyIdx) const
	Get the sumpt for a given object referenced by index.
bool	setCalSumpt (const std::vector< float > &calsumptvec)
	Set the vector of sumpt.
bool	setCalSumpt (size_t keyIdx, float calsumpt)
	Set calo constituent sumpt for a given contributing object referenced by index.
const std::vector< MissingETBase::Types::bitmask_t > &	calkey () const
	Get the vector of cal keys.
MissingETBase::Types::bitmask_t	calkey (size_t keyIdx) const
	Get the key for a given entry referenced by index.
bool	setCalKey (const std::vector< MissingETBase::Types::bitmask_t > &calkeyvec)
	Set the vector of keys.
bool	setCalKey (size_t keyIdx, MissingETBase::Types::bitmask_t calkey)
	Set calo key for a given contributing entry referenced by index.
bool	setCalVec (size_t keyIdx, const ConstVec &cvec=ConstVec())
	Set the calo constituent vector of an object contribution referenced by index.
bool	setCalVec (size_t keyIdx, float calpx, float calpy, float calpz, float ce, float sumpt)
	Set the calo constituent vectors of an object contribution referenced by index.
bool	addCalVec (MissingETBase::Types::bitmask_t key, float calpx, float calpy, float calpz, float cale, float sumpt)
	Add a key/vector pair for calo contributions.
bool	clearCalVecs ()
	Reset the calo constituent vectors and keys.
const std::vector< float > &	trkpx () const
	Get the vector of \( P_{x} \).
float	trkpx (size_t keyIdx) const
	Get the vector \( P_{x} \) for a given object referenced by index.
bool	setTrkPx (const std::vector< float > &trkpxvec)
	Set the vector of \( P_{x} \).
bool	setTrkPx (size_t keyIdx, float trkpx)
	Set track constituent vector \( P_{x} \) for a given contributing object referenced by index.
const std::vector< float > &	trkpy () const
	Get the vector of \( P_{y} \).
float	trkpy (size_t keyIdx) const
	Get the vector \( P_{y} \) for a given object referenced by index.
bool	setTrkPy (const std::vector< float > &trkpyvec)
	Set the vector of \( P_{y} \).
bool	setTrkPy (size_t keyIdx, float trkpy)
	Set track constituent vector \( P_{y} \) for a given contributing object referenced by index.
const std::vector< float > &	trkpz () const
	Get the vector of \( P_{z} \).
float	trkpz (size_t keyIdx) const
	Get the vector \( P_{z} \) for a given object referenced by index.
bool	setTrkPz (const std::vector< float > &trkpzvec)
	Set the vector of \( P_{z} \).
bool	setTrkPz (size_t keyIdx, float trkpz)
	Set track constituent vector \( P_{z} \) for a given contributing object referenced by index.
const std::vector< float > &	trke () const
	Get the vector of \( E \).
float	trke (size_t keyIdx) const
	Get the vector \( E \) for a given object referenced by index.
bool	setTrkE (const std::vector< float > &trkevec)
	Set the vector of \( E \).
bool	setTrkE (size_t keyIdx, float trke)
	Set track constituent vector \( E \) for a given contributing object referenced by index.
const std::vector< float > &	trksumpt () const
	Get the vector of \( E \).
float	trksumpt (size_t keyIdx) const
	Get the vector \( E \) for a given object referenced by index.
bool	setTrkSumpt (const std::vector< float > &trksumptvec)
	Set the vector of \( E \).
bool	setTrkSumpt (size_t keyIdx, float trksumpt)
	Set track constituent vector \( E \) for a given contributing object referenced by index.
const std::vector< MissingETBase::Types::bitmask_t > &	trkkey () const
	Get the vector of trk keys.
MissingETBase::Types::bitmask_t	trkkey (size_t keyIdx) const
	Get the key for a given entry referenced by index.
bool	setTrkKey (const std::vector< MissingETBase::Types::bitmask_t > &trkkeyvec)
	Set the vector of keys.
bool	setTrkKey (size_t keyIdx, MissingETBase::Types::bitmask_t trkkey)
	Set trk key for a given contributing entry referenced by index.
bool	setTrkVec (size_t keyIdx, const ConstVec &cvec=ConstVec())
	Set the track constituent vector of an object contribution referenced by index.
bool	setTrkVec (size_t keyIdx, float trkpx, float trkpy, float trkpz, float trke, float sumpt)
	Set the track constituent vectors of an object contribution referenced by index.
bool	addTrkVec (MissingETBase::Types::bitmask_t key, float trkpx, float trkpy, float trkpz, float ce, float sumpt)
	Add a key/vector pair for calo contributions.
bool	clearTrkVecs ()
	Reset the track constituent vectors and keys.
float	jettrkpx () const
	Get the vector \( P_{x} \) for a given object referenced by index.
float	jettrkpy () const
	Get the vector \( P_{y} \) for a given object referenced by pointer.
float	jettrkpz () const
	Get the vector \( P_{z} \) for a given object referenced by pointer.
float	jettrke () const
	Get the vector \( E \) for a given object referenced by index.
float	jettrksumpt () const
	Get the sumpt for a given object referenced by index.
void	setJetTrkPx (float px)
	Set track constituent vector \( P_{x} \) for the reference jet.
void	setJetTrkPy (float py)
	Set track constituent vector \( P_{y} \) for the reference jet.
void	setJetTrkPz (float pz)
	Set track constituent vector \( P_{z} \) for the reference jet.
void	setJetTrkE (float e)
	Set track constituent vector \( E \) for the reference jet.
void	setJetTrkSumpt (float sumpt)
	Set track constituent vector \( E \) for the reference jet.
void	setJetTrkVec (const ConstVec &cvec=ConstVec())
	Set the track constituent vector for the reference jet.
void	setJetTrkVec (float px, float py, float pz, float ce, float sumpt)
	Set the track constituent vector for the reference jet.
const MissingETBase::Types::jetlink_t &	jetLink () const
	Get the link to the reference jet.
bool	setJetLink (const MissingETBase::Types::jetlink_t &jetLnk)
	Set the link to the reference jet.
const MissingETBase::Types::objlink_vector_t &	objectLinks () const
	Get the vector of links to the contributing physics or signal objects.
bool	setObjectLinks (const MissingETBase::Types::objlink_vector_t &objLnks)
	Set the vector of links to the contributing physics or signal objects.
const std::vector< std::vector< size_t > > &	overlapIndices () const
	Get the list of object overlapIndices.
std::vector< size_t >	overlapIndices (const IParticle *pPart) const
	Get the overlap indices for a given object referenced by pointer.
std::vector< size_t >	overlapIndices (size_t objIdx) const
	Get the overlap indices for a given object referenced by index.
const std::vector< std::vector< unsigned char > > &	overlapTypes () const
	Get the list of object overlapTypes.
std::vector< unsigned char >	overlapTypes (const IParticle *pPart) const
	Get the overlap types for a given object referenced by pointer.
std::vector< unsigned char >	overlapTypes (size_t objIdx) const
	Get the overlap types for a given object referenced by index.
void	clearOverlaps ()
	Clear the vectors of overlap indices.
bool	setOverlaps (const std::vector< std::vector< size_t > > &overlapIndices, const std::vector< std::vector< unsigned char > > &overlapTypes)
	Set the vector of overlap indices and types.
bool	setOverlaps (const IParticle *pPart, const std::vector< size_t > &overlapIndices, const std::vector< unsigned char > &overlapTypes)
	Set overlap indices and types for a given contributing object referenced by pointer.
bool	setOverlaps (size_t objIdx, const std::vector< size_t > &overlapIndices, const std::vector< unsigned char > &overlapTypes)
	Set overlap indices and types for a given contributing object referenced by index.
void	setOverrideMom (const std::map< const IParticle *, ConstVec > &pOverride)
	Set override momenta.
std::map< const IParticle *, ConstVec >	overrideMom ()
	Get override momenta.
void	addOverrideMom (std::map< const IParticle *, ConstVec > &pOverride)
	Extend override momentum map.
Specific methods for manipulating the association description data
bool	removeContrib (const IParticle *pPart)
	Remove a contribution referenced by an object pointer.
bool	removeContrib (size_t objIdx)
	Remove a contribution referenced by an index.
bool	removeContrib ()
	Remove all contributions.
bool	resetContrib (const IParticle *pPart)
	Reset the contribution parameters of an object referenced by a pointer.
bool	resetContrib (size_t objIdx)
	Reset the contribution parameters of an object referenced by an index.
bool	resetContrib ()
	Reset all contribution parameters.
Dedicated accessors for linked objects
const Jet *	refJet () const
	Access reference jet.
const JetContainer *	refJetContainer () const
	Access reference jet container holding reference jet.
size_t	refJetIndex () const
	Access index of reference jet in its container.
std::vector< const IParticle * >	objects () const
	Access contributing objects.
std::vector< const IParticle * >	objects (std::vector< ConstVec > &calVecs, std::vector< ConstVec > &trkVecs) const
	Access contributing objects and retrieve constituent vectors.
std::vector< const IParticle * >	objects (const std::vector< float > *&calpxPtr, const std::vector< float > *&calpyPtr, const std::vector< float > *&calpzPtr, const std::vector< float > *&calePtr, const std::vector< float > *&calsumptPtr, const std::vector< float > *&trkpxPtr, const std::vector< float > *&trkpyPtr, const std::vector< float > *&trkpzPtr, const std::vector< float > *&trkePtr, const std::vector< float > *&trksumptPtr) const
	Access contributing objects and retrieve constituent vectors.
ConstVec	calVec (const IParticle *pPart) const
	Get calo constituent vector for a given object.
ConstVec	calVec (size_t keyIdx) const
	Get calo constituent vector for a given entry (index) in the contributing object list.
ConstVec	trkVec (const IParticle *pPart) const
	Get track constituent vector for a given object.
ConstVec	trkVec (size_t keyIdx) const
	Get track constituent vector for a given entry (index) in the contributing object list.
ConstVec	jetTrkVec () const
	Get track constituent vector for the reference jet.
Adding and retrieving selection and overlap information
bool	addOverlap (const IParticle *pPart, size_t index, unsigned char type)
	Add overlap index for a given contributing object referenced by pointer.
bool	addOverlap (size_t objIdx, size_t index, unsigned char type)
	Add overlap index for a given contributing object referenced by index.
bool	identifyOverlaps ()
	Loop over contributing objects to identify those that share constituents.
bool	identifyOverlaps (size_t objIdx)
	Search association for particles that share constituents with this one.
bool	identifyOverlaps (const IParticle *pPart)
	Search association for particles that share constituents with this one.
bool	hasOverlaps (const MissingETAssociationHelper &helper, size_t objIdx, MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster) const
	Check if any selected particles overlap this one.
bool	hasOverlaps (const MissingETAssociationHelper &helper, const IParticle *pPart, MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster) const
	Check if any selected particles overlap this one.
bool	hasAlternateConstVec () const
xAOD::JetFourMom_t	getAlternateConstVec () const
ConstVec	overlapCalVec (const MissingETAssociationHelper &helper) const
	Retrieve total cluster-based vector to be subtracted from the jet.
ConstVec	overlapTrkVec (const MissingETAssociationHelper &helper) const
	Retrieve total track-based vector to be subtracted from the jet.
bool	containsSignal (const IParticle *pSig) const
	Check if this signal object matches the constituents of any contributing objects.
bool	containsPhysics (const IParticle *pPhys) const
	Check if this physics object matches any contributing objects.
bool	isMisc () const
	Check if this association is a miscellaneous association.
bool	checkUsage (const MissingETAssociationHelper &helper, const IParticle *pSig, MissingETBase::UsageHandler::Policy p) const
	Check if this signal object matches the constituents of any flagged contributing objects.
Allocating and accessing objects in the contribution
size_t	findIndex (const IParticle *pPart) const
	Find index of given object in contributing object store.
List management and information
size_t	size () const
	Update all internally used ElementLink instances.
size_t	sizeCal () const
size_t	sizeTrk () const
bool	empty () const
	Empty list of contributing objects indicator.
Comparators
Parameters [in] contrib reference to non-modifiable contribution object to compare to.
bool	operator== (const MissingETAssociation_v1 &contrib) const
bool	operator!= (const MissingETAssociation_v1 &contrib) const
	Equality.

Static Public Member Functions
static bool	testPolicy (const xAOD::IParticle &part, MissingETBase::UsageHandler::Policy p)

Static Public Attributes
static constexpr bool	supportsThinning = true
	Mark that this type supports thinning operations.

Protected Member Functions
void	createPrivateStore ()
	Function initialising the object to work in standalone mode.
bool	noPrivateData () const
	True if this element has no private data.
bool	havePrivateData () const
	True if this element currently has private data.
bool	hadPrivateData () const
	True if this element had private data before it was added to its current container.
Internal non-const accessors
The underlying data model uses the auxiliary store MissingETAuxComposition_v1, which only employs low level data structures and ElementLinks. The accessors forward their specific request to static accessors, which retrieve the data by internally used names.
MissingETBase::Types::objlink_vector_t &	f_objectLinks ()
	Non-const link reference.
MissingETBase::Types::jetlink_t &	f_jetLink ()
	Non-const link reference.
std::vector< float > &	f_calpx ()
std::vector< float > &	f_calpy ()
std::vector< float > &	f_calpz ()
std::vector< float > &	f_cale ()
std::vector< float > &	f_calsumpt ()
std::vector< MissingETBase::Types::bitmask_t > &	f_calkey ()
std::vector< float > &	f_trkpx ()
std::vector< float > &	f_trkpy ()
std::vector< float > &	f_trkpz ()
std::vector< float > &	f_trke ()
std::vector< float > &	f_trksumpt ()
std::vector< MissingETBase::Types::bitmask_t > &	f_trkkey ()
float &	f_jettrkpx ()
float &	f_jettrkpy ()
float &	f_jettrkpz ()
float &	f_jettrke ()
float &	f_jettrksumpt ()
char &	f_isMisc ()
std::vector< std::vector< size_t > > &	f_overlapIndices ()
	record overlapIndices between constributing objects
std::vector< std::vector< unsigned char > > &	f_overlapTypes ()
	record overlapTypes between constributing objects
Helpers
bool	f_removeContrib (size_t objIdx)
	Copy the contribution data from a source.
void	copyData (const MissingETAssociation_v1 &assocDescr)
template<class POBJ, class LINK>
void	f_setObject (const POBJ *pObj, LINK &elemLink)
	Generalized link manager.
template<class LINK>
bool	f_setLink (LINK &elemLink)
Management of local cache
void	initCache ()
	initialise cache for overlap removal decisions

Static Protected Member Functions
static bool	testPolicy (xAOD::Type::ObjectType type, MissingETBase::UsageHandler::Policy p)

Protected Attributes
Internal data for local cache
std::vector< std::vector< ElementLink< IParticleContainer > > >	m_objConstLinks
	Cache object constituents for overlap-finding.

Private Types
enum class	PrivateStoreState : uint8_t { NO_PRIVATE = 0 , HAVE_PRIVATE = 1 , HAD_PRIVATE = 2 }
	The current private data state. More...

Private Member Functions
void	releasePrivateStoreForDtor ()
	Out-of-line portion of destructor.
void	setIndex (size_t index, SG::AuxVectorData *container)
	Set the index/container for this element.
bool	setIndexPrivate (size_t index, SG::AuxVectorData *container)
	Set the index/container for this element.
void	makePrivateStore1 (const void *other, bool warnUnlocked)
	Create a new private store for this object and copy aux data.
void	makePrivateStore1 (const AuxElement *other, bool warnUnlocked)
	Create a new private store for this object and copy aux data.
AuxElementStandaloneData *	setStore1 (const SG::IConstAuxStore *store)
	Set the store associated with this object.
void	clearAux ()
	Clear all aux data associated with this element.
void	copyAux (const ConstAuxElement &other, bool warnUnlocked=false)
	Copy aux data from another object.
void	setNoPrivateData ()
	Record that this element does not have private data.
void	setHavePrivateData ()
	Record that this element currently has private data.
void	setHadPrivateData ()
	Record that this element used to have private data.

Static Private Member Functions
static void	clearAuxHelper (AuxVectorData &container, size_t index)
	Clear all aux data associated with an element.
static void	copyAuxHelper (AuxVectorData &container, size_t index, const ConstAuxElement &other, bool warnUnlocked)
	Copy aux data from another object.

Private Attributes
std::map< const IParticle *, ConstVec >	m_override
const SG::AuxVectorData *	m_container
	The container of which this object is an element.
size_t	m_index
	The index of this element within its container.
PrivateStoreState	m_privateStoreState

Static Private Attributes
static const SG::AuxElement::Accessor< std::vector< float > >	m_acc_calpx
static const SG::AuxElement::Accessor< std::vector< float > >	m_acc_calpy
static const SG::AuxElement::Accessor< std::vector< float > >	m_acc_calpz
static const SG::AuxElement::Accessor< std::vector< float > >	m_acc_cale
static const SG::AuxElement::Accessor< std::vector< float > >	m_acc_calsumpt
static const SG::AuxElement::Accessor< std::vector< float > >	m_acc_trkpx
static const SG::AuxElement::Accessor< std::vector< float > >	m_acc_trkpy
static const SG::AuxElement::Accessor< std::vector< float > >	m_acc_trkpz
static const SG::AuxElement::Accessor< std::vector< float > >	m_acc_trke
static const SG::AuxElement::Accessor< std::vector< float > >	m_acc_trksumpt
static const SG::AuxElement::Accessor< float >	m_acc_jettrkpx
static const SG::AuxElement::Accessor< float >	m_acc_jettrkpy
static const SG::AuxElement::Accessor< float >	m_acc_jettrkpz
static const SG::AuxElement::Accessor< float >	m_acc_jettrke
static const SG::AuxElement::Accessor< float >	m_acc_jettrksumpt

Detailed Description

MET association descriptor contains object links and corresponding parameters.

Definition at line 24 of file MissingETAssociation_v1.h.

Member Typedef Documentation

Accessor

template<class T, class ALLOC = AuxAllocator_t<T>>

using SG::AuxElement::Accessor = SG::Accessor<T, ALLOC>

inherited

Definition at line 572 of file AuxElement.h.

ConstAccessor

template<class T, class ALLOC = AuxAllocator_t<T>>

using SG::AuxElement::ConstAccessor = SG::ConstAccessor<T, ALLOC>

inherited

Definition at line 569 of file AuxElement.h.

Decorator

template<class T, class ALLOC = AuxAllocator_t<T>>

using SG::AuxElement::Decorator = SG::Decorator<T, ALLOC>

inherited

Definition at line 575 of file AuxElement.h.

TypelessConstAccessor

using SG::AuxElement::TypelessConstAccessor = ConstAuxElement::TypelessConstAccessor

inherited

Definition at line 566 of file AuxElement.h.

Member Enumeration Documentation

PrivateStoreState

enum class SG::IAuxElement::PrivateStoreState : uint8_t

strongprivateinherited

The current private data state.

Enumerator
NO_PRIVATE
HAVE_PRIVATE
HAD_PRIVATE

Definition at line 131 of file IAuxElement.h.

  {
    NO_PRIVATE = 0,
    HAVE_PRIVATE = 1,
    HAD_PRIVATE = 2,
  };

Constructor & Destructor Documentation

MissingETAssociation_v1() [1/3]

xAOD::MissingETAssociation_v1::MissingETAssociation_v1 ( bool createStore = false )

explicit

Default constructor.

Definition at line 94 of file MissingETAssociation_v1.cxx.

    : SG::AuxElement()
  {
 
    if( createStore ) createPrivateStore();
    initCache();
  }

MissingETAssociation_v1() [2/3]

xAOD::MissingETAssociation_v1::MissingETAssociation_v1	(	const Jet *	pjet,
		bool	isMisc = false )

Construct with a link to a Jet object.

Definition at line 102 of file MissingETAssociation_v1.cxx.

    : SG::AuxElement()
  {
 
    createPrivateStore();
    f_isMisc() = isMisc;
    setRefJet( pJet );
    initCache();
  }

MissingETAssociation_v1() [3/3]

xAOD::MissingETAssociation_v1::MissingETAssociation_v1

(

const MissingETAssociation_v1 &

assocDescr

)

Copy constructor.

Definition at line 112 of file MissingETAssociation_v1.cxx.

    : SG::AuxElement(assocDescr)
  {
    this->makePrivateStore(&assocDescr);
    initCache();
  }

~MissingETAssociation_v1()

xAOD::MissingETAssociation_v1::~MissingETAssociation_v1 ( )

virtual

Assignment operator.

Definition at line 146 of file MissingETAssociation_v1.cxx.

{ }

Member Function Documentation

addCalVec()

bool xAOD::MissingETAssociation_v1::addCalVec	(	MissingETBase::Types::bitmask_t	key,
		float	calpx,
		float	calpy,
		float	calpz,
		float	cale,
		float	sumpt )

Add a key/vector pair for calo contributions.

Definition at line 345 of file MissingETAssociation_v1.cxx.

                                                                                                                                    {
    for(MissingETBase::Types::bitmask_t testkey : this->f_calkey()) {
      // quit if key already exists.
      if(key==testkey) return false;
    }
    this->f_calkey().push_back(key);
    this->f_calpx().push_back(calpx);
    this->f_calpy().push_back(calpy);
    this->f_calpz().push_back(calpz);
    this->f_cale().push_back(cale);
    this->f_calsumpt().push_back(sumpt);
    return true;
  }

addObject()

bool xAOD::MissingETAssociation_v1::addObject	(	const IParticle *	pPart,
		const std::vector< const IParticle * > &	constlist )

Add object (particle) from pointer reference with individual constituent vectors.

Definition at line 152 of file MissingETAssociation_v1.cxx.

  {
    // check if object is in store
 
    size_t idx(this->findIndex(pPart));
    // found - add const vectors
    if ( idx != MissingETBase::Numerical::invalidIndex() )
      { 
        m_objConstLinks[idx].clear();
        m_objConstLinks[idx].reserve(constlist.size());
        for(const auto& signal : constlist) {
          const IParticleContainer* pCont = static_cast<const IParticleContainer*>(signal->container());
          MissingETBase::Types::objlink_t el(*pCont,signal->index());
          m_objConstLinks[idx].push_back(el);
        }
        return false; }
    // new object
    else
      {
        MissingETBase::Types::objlink_t oLnk; f_setObject<IParticle,MissingETBase::Types::objlink_t>(pPart,oLnk); 
        // add to stores
        this->f_objectLinks().push_back(oLnk);
        vector<MissingETBase::Types::objlink_t > linklist;
        linklist.reserve(constlist.size());
        for(const auto& signal : constlist) {
          const IParticleContainer* pCont = static_cast<const IParticleContainer*>(signal->container());
          MissingETBase::Types::objlink_t el(*pCont,signal->index());
          linklist.push_back(el);
        }
        m_objConstLinks.push_back(linklist);
        this->f_overlapIndices().emplace_back(0);
        this->f_overlapTypes().emplace_back(0);
        bool linkset = f_setLink<MissingETBase::Types::objlink_t>(oLnk);
        return linkset;
      }
  }

addOverlap() [1/2]

bool xAOD::MissingETAssociation_v1::addOverlap	(	const IParticle *	pPart,
		size_t	index,
		unsigned char	type )

Add overlap index for a given contributing object referenced by pointer.

addOverlap() [2/2]

bool xAOD::MissingETAssociation_v1::addOverlap	(	size_t	objIdx,
		size_t	index,
		unsigned char	type )

Add overlap index for a given contributing object referenced by index.

Definition at line 589 of file MissingETAssociation_v1.cxx.

  {
    if ( objIdx != MissingETBase::Numerical::invalidIndex() && objIdx < this->f_overlapIndices().size() ) {
      this->f_overlapIndices()[objIdx].push_back(overlapIndex);
      this->f_overlapTypes()[objIdx].push_back(overlapType);
      return true; 
    } else { return false; }
  }

addOverrideMom()

void xAOD::MissingETAssociation_v1::addOverrideMom

(

std::map< const IParticle *, ConstVec > &

pOverride

)

Extend override momentum map.

addTrkVec()

bool xAOD::MissingETAssociation_v1::addTrkVec	(	MissingETBase::Types::bitmask_t	key,
		float	trkpx,
		float	trkpy,
		float	trkpz,
		float	ce,
		float	sumpt )

Add a key/vector pair for calo contributions.

Definition at line 379 of file MissingETAssociation_v1.cxx.

                                                                                                                                    {
    for(MissingETBase::Types::bitmask_t testkey : this->f_trkkey()) {
      // quit if key already exists.
      if(key==testkey) return false;
    }
    this->f_trkkey().push_back(key);
    this->f_trkpx().push_back(trkpx);
    this->f_trkpy().push_back(trkpy);
    this->f_trkpz().push_back(trkpz);
    this->f_trke().push_back(trke);
    this->f_trksumpt().push_back(sumpt);
    return true;
  }

assign()

void SG::AuxElement::assign ( const AuxElement & other, bool warnUnlocked = false )

inherited

Assignment.

Parameters

other	The object from which we're assigning.
warnUnlocked	If true, then warn when we skip unlocked decorations.

We don't copy container/index, as assignment doesn't change where this object is. However, if we have aux data, then we copy aux data if we're copying from an object that also has it; otherwise, if we're copying from an object with no aux data, then we clear ours.

auxdata() [1/4]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::reference_type SG::AuxElement::auxdata ( const std::string & name )

inherited

Fetch an aux data variable, as a non-const reference.

Parameters

name	Name of the aux variable.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

auxdata() [2/4]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type SG::AuxElement::auxdata ( const std::string & name ) const

inherited

Fetch an aux data variable, as a const reference.

Parameters

name	Name of the aux variable.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor or ConstAccessor classes.

auxdata() [3/4]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::reference_type SG::AuxElement::auxdata ( const std::string & name, const std::string & clsname )

inherited

Fetch an aux data variable, as a non-const reference.

Parameters

name	Name of the aux variable.
clsname	The name of the associated class. May be blank.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

auxdata() [4/4]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type SG::AuxElement::auxdata ( const std::string & name, const std::string & clsname ) const

inherited

Fetch an aux data variable, as a const reference.

Parameters

name	Name of the aux variable.
clsname	The name of the associated class. May be blank.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor or ConstAccessor classes.

auxdataConst() [1/2]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type SG::AuxElement::auxdataConst ( const std::string & name ) const

inherited

Fetch an aux data variable, as a const reference.

Parameters

name	Name of the aux variable.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the ConstAccessor class.

auxdataConst() [2/2]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type SG::AuxElement::auxdataConst ( const std::string & name, const std::string & clsname ) const

inherited

Fetch an aux data variable, as a const reference.

Parameters

name	Name of the aux variable.
clsname	The name of the associated class. May be blank.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the ConstAccessor class.

auxdecor() [1/2]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Decorator< T, ALLOC >::reference_type SG::AuxElement::auxdecor ( const std::string & name ) const

inherited

Fetch an aux decoration, as a non-const reference.

Parameters

name	Name of the aux variable.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

auxdecor() [2/2]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Decorator< T, ALLOC >::reference_type SG::AuxElement::auxdecor ( const std::string & name, const std::string & clsname ) const

inherited

Fetch an aux decoration, as a non-const reference.

Parameters

name	Name of the aux variable.
clsname	The name of the associated class. May be blank.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

cale() [1/2]

const std::vector< float > & xAOD::MissingETAssociation_v1::cale

(

)

const

Get the vector of \( E \).

cale() [2/2]

float xAOD::MissingETAssociation_v1::cale

(

size_t

keyIdx

)

const

Get the vector \( E \) for a given object referenced by index.

Definition at line 473 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->cale()[keyIdx] : MissingETBase::Numerical::ceError(); }

calkey() [1/2]

const std::vector< MissingETBase::Types::bitmask_t > & xAOD::MissingETAssociation_v1::calkey

(

)

const

Get the vector of cal keys.

calkey() [2/2]

MissingETBase::Types::bitmask_t xAOD::MissingETAssociation_v1::calkey

(

size_t

keyIdx

)

const

Get the key for a given entry referenced by index.

Definition at line 477 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->calkey()[keyIdx] : MissingETBase::Numerical::invalidIndex(); }

calpx() [1/3]

const std::vector< float > & xAOD::MissingETAssociation_v1::calpx

(

)

const

Get the vector of \( P_{x} \).

calpx() [2/3]

float xAOD::MissingETAssociation_v1::calpx

(

const IParticle *

pPart

)

const

Get the vector \( P_{x} \) for a given object referenced by pointer.

calpx() [3/3]

float xAOD::MissingETAssociation_v1::calpx

(

size_t

keyIdx

)

const

Get the vector \( P_{x} \) for a given object referenced by index.

Definition at line 467 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->calpx()[keyIdx] : MissingETBase::Numerical::cpxError(); }

calpy() [1/2]

const std::vector< float > & xAOD::MissingETAssociation_v1::calpy

(

)

const

Get the vector of \( P_{y} \).

calpy() [2/2]

float xAOD::MissingETAssociation_v1::calpy

(

size_t

keyIdx

)

const

Get the vector \( P_{y} \) for a given object referenced by index.

Definition at line 469 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->calpy()[keyIdx] : MissingETBase::Numerical::cpyError(); }

calpz() [1/2]

const std::vector< float > & xAOD::MissingETAssociation_v1::calpz

(

)

const

Get the vector of \( P_{z} \).

calpz() [2/2]

float xAOD::MissingETAssociation_v1::calpz

(

size_t

keyIdx

)

const

Get the vector \( P_{z} \) for a given object referenced by index.

Definition at line 471 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->calpz()[keyIdx] : MissingETBase::Numerical::cpzError(); }

calsumpt() [1/2]

const std::vector< float > & xAOD::MissingETAssociation_v1::calsumpt

(

)

const

Get the vector of sumpt.

calsumpt() [2/2]

float xAOD::MissingETAssociation_v1::calsumpt

(

size_t

keyIdx

)

const

Get the sumpt for a given object referenced by index.

Definition at line 475 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() ? this->calsumpt()[keyIdx] : MissingETBase::Numerical::sumptError(); }

calVec() [1/2]

MissingETAssociation_v1::ConstVec xAOD::MissingETAssociation_v1::calVec

(

const IParticle *

pPart

)

const

Get calo constituent vector for a given object.

Definition at line 538 of file MissingETAssociation_v1.cxx.

  {
    MissingETBase::Types::constvec_t totalvec;
    for (size_t iKey = 0; iKey < this->sizeCal(); iKey++) {
      if (this->calkey(iKey) & getObjMask(this->findIndex(pPart)))
        totalvec+=this->calVec(iKey);
    }
    return totalvec;
  }

calVec() [2/2]

constvec_t xAOD::MissingETAssociation_v1::calVec

(

size_t

keyIdx

)

const

Get calo constituent vector for a given entry (index) in the contributing object list.

Definition at line 558 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeCal() 
      ? constvec_t(this->calpx(keyIdx),this->calpy(keyIdx),this->calpz(keyIdx),this->cale(keyIdx),this->calsumpt(keyIdx)) 
      : constvec_t(MissingETBase::Numerical::cpxError(),MissingETBase::Numerical::cpyError(),MissingETBase::Numerical::cpzError(),MissingETBase::Numerical::ceError(),MissingETBase::Numerical::sumptError()); }

checkUsage()

bool xAOD::MissingETAssociation_v1::checkUsage	(	const MissingETAssociationHelper &	helper,
		const IParticle *	pSig,
		MissingETBase::UsageHandler::Policy	p ) const

Check if this signal object matches the constituents of any flagged contributing objects.

Definition at line 816 of file MissingETAssociation_v1.cxx.

  {
    if(MissingETAssociation_v1::testPolicy(*pSig,p)) {
      const IParticleContainer* pCont = static_cast<const IParticleContainer*>(pSig->container());
      MissingETBase::Types::objlink_t el(*pCont,pSig->index());
      for(size_t iObj=0; iObj<this->objectLinks().size(); ++iObj) {
        if(helper.objSelected(this,iObj)) {
          for(const auto& link : m_objConstLinks[iObj]) {
            if(el == link) return true;
          }
        }
      }
    }
    return false;
  }

clearAux()

void SG::AuxElement::clearAux ( )

privateinherited

Clear all aux data associated with this element.

If this object has no associated store, this does nothing. If the associated aux data is const, this throws ExcConstAuxData.

Definition at line 580 of file AuxElement.cxx.

{
  if (!m_container) return;
  clearAuxHelper (*container(), index());
}

clearAuxHelper()

void SG::AuxElement::clearAuxHelper ( AuxVectorData & container, size_t index )

staticprivateinherited

Clear all aux data associated with an element.

Parameters

container	Container of the element.
index	Index of this element within the container.

If the associated aux data is const, this throws ExcConstAuxData.

Definition at line 639 of file AuxElement.cxx.

{
  if (!container.hasStore()) return;
  if (!container.hasNonConstStore()) {
    throw SG::ExcConstAuxData ("clearAux", SG::null_auxid);
  }
 
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
  for (SG::auxid_t auxid : container.getWritableAuxIDs()) {
    r.clear (auxid, container, index, 1);
  }
}

clearCache()

void SG::AuxElement::clearCache ( )

inherited

Clear the cached aux data pointers.

You should call this any time something changes in the aux store that could invalidate the vector pointers.

Definition at line 339 of file AuxElement.cxx.

{
  if (container())
    container()->clearCache();
}

clearCalVecs()

bool xAOD::MissingETAssociation_v1::clearCalVecs

(

)

Reset the calo constituent vectors and keys.

clearDecorations()

bool SG::AuxElement::clearDecorations ( ) const

inherited

Clear all decorations.

Erase all decorations from an associated store, restoring the state to when lock was called.

Returns true if there were any decorations that were cleared, false if the store did not contain any decorations.

Definition at line 428 of file AuxElement.cxx.

{
  if (havePrivateData())
    return m_container->clearDecorations();
  return false;
}

clearOverlaps()

void xAOD::MissingETAssociation_v1::clearOverlaps

(

)

Clear the vectors of overlap indices.

Definition at line 411 of file MissingETAssociation_v1.cxx.

  {
    this->f_overlapIndices().clear();
    this->f_overlapIndices().resize(this->f_overlapIndices().size(),vector<size_t>(0));
    this->f_overlapTypes().clear();
    this->f_overlapTypes().resize(this->f_overlapTypes().size(),vector<unsigned char>(0));
  }

clearTrkVecs()

bool xAOD::MissingETAssociation_v1::clearTrkVecs

(

)

Reset the track constituent vectors and keys.

container() [1/2]

SG::AuxVectorData * SG::AuxElement::container ( )

inherited

Return the container holding this element.

container() [2/2]

const SG::AuxVectorData * SG::AuxElement::container ( ) const

inherited

Return the container holding this element.

containsPhysics()

bool xAOD::MissingETAssociation_v1::containsPhysics

(

const IParticle *

pPhys

)

const

Check if this physics object matches any contributing objects.

Definition at line 790 of file MissingETAssociation_v1.cxx.

  {
    for(const auto& link : this->objectLinks()) {
      if(link.isValid()) {
        if(pPhys == *link) {
          return true;
        }
      }
    }
    return false;
  }

containsSignal()

bool xAOD::MissingETAssociation_v1::containsSignal

(

const IParticle *

pSig

)

const

Check if this signal object matches the constituents of any contributing objects.

Definition at line 802 of file MissingETAssociation_v1.cxx.

  {
    for(size_t iObj=0; iObj<this->objectLinks().size(); ++iObj) {
      for(const auto& link : m_objConstLinks[iObj]) {
        if(link.isValid()) {
          if(pSig == *link) {
            return true;
          }
        }
      }
    }
    return false;
  }

copyAux()

void SG::AuxElement::copyAux ( const ConstAuxElement & other, bool warnUnlocked = false )

privateinherited

Copy aux data from another object.

Parameters

other	The object from which to copy.
warnUnlocked	If true, then warn when we skip unlocked decorations.

If this object has no associated store, this does nothing. If the associated aux data is const, this throws ExcConstAuxData.

All aux data items from other are copied to this object. Any aux data items associated with this object that are not present in other are cleared. (If other has no aux data, then all aux data items for this object are cleared.)

Definition at line 600 of file AuxElement.cxx.

{
  if (!m_container) return;
  copyAuxHelper (*container(), index(), other, warnUnlocked);
}

copyAuxHelper()

void SG::AuxElement::copyAuxHelper ( AuxVectorData & container, size_t index, const ConstAuxElement & other, bool warnUnlocked )

staticprivateinherited

Copy aux data from another object.

Parameters

container	Container of the element.
index	Index of this element within the container.
other	The object from which to copy.
warnUnlocked	If true, then warn when we skip unlocked decorations.

If the associated aux data is const, this throws ExcConstAuxData.

All aux data items from other are copied to this object. Any aux data items associated with this object that are not present in other are cleared. (If other has no aux data, then all aux data items for this object are cleared.)

Definition at line 667 of file AuxElement.cxx.

{
  if (!container.hasStore()) return;
  if (!container.hasNonConstStore())
    throw SG::ExcConstAuxData ("copyAux");
 
  const SG::AuxVectorData* ocont = other.container();
 
  if (!ocont || !ocont->hasStore()) {
    AuxElement::clearAuxHelper (container, index);
    return;
  }
 
#ifndef XAOD_STANDALONE
  const SG::auxid_set_t& other_decors = ocont->getDecorIDs();
#endif
  SG::auxid_set_t other_ids = ocont->getAuxIDs();
 
  size_t oindex = other.index();
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  for (SG::auxid_t auxid : other_ids) {
#ifndef XAOD_STANDALONE
    if (other_decors.test (auxid)) {
      // Don't copy decorations --- another thread may be modifying them.
      other_ids.reset (auxid);
      // Warn if we skip a decoration (except for mcEventWeights,
      // for which this is expected).
      if (warnUnlocked && r.getName(auxid) != "mcEventWeights") {
        std::ostringstream ss;
        ss << "skipped unlocked decoration " << r.getName(auxid)
           << " (" << auxid << ")";
        ATHCONTAINERS_WARNING("copyAux", ss.str());
      }
    }
    else
#endif
    if (!r.isLinked (auxid)) {
      r.copy (auxid, container, index, *ocont, oindex, 1);
    }
  }
 
  for (SG::auxid_t auxid : container.getWritableAuxIDs()) {
    if (!other_ids.test (auxid)) {
      r.clear (auxid, container, index, 1);
    }
  }
}

copyData()

void xAOD::MissingETAssociation_v1::copyData ( const MissingETAssociation_v1 & assocDescr )

protected

createPrivateStore()

void xAOD::MissingETAssociation_v1::createPrivateStore ( )

protected

Function initialising the object to work in standalone mode.

Definition at line 836 of file MissingETAssociation_v1.cxx.

  {
 
    makePrivateStore();
    f_jetLink()    = jetlink_t();
    f_objectLinks().clear();
    f_overlapIndices().clear();
    f_overlapTypes().clear();
    f_isMisc() = false;
    f_calpx().clear();
    f_calpy().clear();
    f_calpz().clear();
    f_cale().clear();
    f_calsumpt().clear();
    f_calkey().clear();
    f_trkpx().clear();
    f_trkpy().clear();
    f_trkpz().clear();
    f_trke().clear();
    f_trksumpt().clear();
    f_trkkey().clear();
    f_jettrkpx() = 0;
    f_jettrkpy() = 0;
    f_jettrkpz() = 0;
    f_jettrke() = 0;
    f_jettrksumpt() = 0;
 
    return;
  }

empty()

bool xAOD::MissingETAssociation_v1::empty

(

)

const

Empty list of contributing objects indicator.

f_cale()

std::vector< float > & xAOD::MissingETAssociation_v1::f_cale ( )

protected

f_calkey()

std::vector< MissingETBase::Types::bitmask_t > & xAOD::MissingETAssociation_v1::f_calkey ( )

protected

f_calpx()

std::vector< float > & xAOD::MissingETAssociation_v1::f_calpx ( )

protected

f_calpy()

std::vector< float > & xAOD::MissingETAssociation_v1::f_calpy ( )

protected

f_calpz()

std::vector< float > & xAOD::MissingETAssociation_v1::f_calpz ( )

protected

f_calsumpt()

std::vector< float > & xAOD::MissingETAssociation_v1::f_calsumpt ( )

protected

f_isMisc()

char & xAOD::MissingETAssociation_v1::f_isMisc ( )

protected

f_jetLink()

MissingETBase::Types::jetlink_t & xAOD::MissingETAssociation_v1::f_jetLink ( )

protected

Non-const link reference.

f_jettrke()

float & xAOD::MissingETAssociation_v1::f_jettrke ( )

protected

f_jettrkpx()

float & xAOD::MissingETAssociation_v1::f_jettrkpx ( )

protected

f_jettrkpy()

float & xAOD::MissingETAssociation_v1::f_jettrkpy ( )

protected

f_jettrkpz()

float & xAOD::MissingETAssociation_v1::f_jettrkpz ( )

protected

f_jettrksumpt()

float & xAOD::MissingETAssociation_v1::f_jettrksumpt ( )

protected

f_objectLinks()

MissingETBase::Types::objlink_vector_t & xAOD::MissingETAssociation_v1::f_objectLinks ( )

protected

Non-const link reference.

f_overlapIndices()

std::vector< std::vector< size_t > > & xAOD::MissingETAssociation_v1::f_overlapIndices ( )

protected

record overlapIndices between constributing objects

f_overlapTypes()

std::vector< std::vector< unsigned char > > & xAOD::MissingETAssociation_v1::f_overlapTypes ( )

protected

record overlapTypes between constributing objects

f_removeContrib()

bool xAOD::MissingETAssociation_v1::f_removeContrib ( size_t objIdx )

protected

Copy the contribution data from a source.

• Parameters

  [in]

  contrib

  reference to non-modifiable contribution object (the source).

Definition at line 218 of file MissingETAssociation_v1.cxx.

  {
    objlink_vector_t::iterator fCon(this->f_objectLinks().begin()); std::advance<objlink_vector_t::iterator>(fCon,objIdx);
    this->f_objectLinks().erase(fCon);
    vector<vector<size_t> >::iterator fOverlapIndices(this->f_overlapIndices().begin()); std::advance<vector<vector<size_t> >::iterator>(fOverlapIndices,objIdx);
    this->f_overlapIndices().erase(fOverlapIndices);
    vector<vector<unsigned char> >::iterator fOverlapTypes(this->f_overlapTypes().begin()); std::advance<vector<vector<unsigned char> >::iterator>(fOverlapTypes,objIdx);
    this->f_overlapTypes().erase(fOverlapTypes);
    this->f_calpx().clear();
    this->f_calpy().clear();
    this->f_calpz().clear();
    this->f_cale().clear();
    this->f_calsumpt().clear();
    this->f_calkey().clear();
    this->f_trkpx().clear();
    this->f_trkpy().clear();
    this->f_trkpz().clear();
    this->f_trke().clear();
    this->f_trksumpt().clear();
    this->f_trkkey().clear();
    return true;
  }

f_setLink()

template<class LINK>

bool xAOD::MissingETAssociation_v1::f_setLink ( LINK & elemLink )

protected

f_setObject()

template<class POBJ, class LINK>

void xAOD::MissingETAssociation_v1::f_setObject ( const POBJ * pObj, LINK & elemLink )

protected

Generalized link manager.

Inserts link data into ElementLink, even if incomplete. At least, the pointer of linked object will be set (except if NULL).

Template Parameters

POBJ	linked object type
LINK	specific ElementLink type

Parameters

[in]	pObj	pointer to non-modifiable object to be linked
[in]	elemLink	reference to modifiable ElementLink object. Initial data content of this object are overwritten.

Note

This is the generalized implementation for e.g. MissingETAssociation_v1::setMET and MissingETAssociation_v1::addObject

f_trke()

std::vector< float > & xAOD::MissingETAssociation_v1::f_trke ( )

protected

f_trkkey()

std::vector< MissingETBase::Types::bitmask_t > & xAOD::MissingETAssociation_v1::f_trkkey ( )

protected

f_trkpx()

std::vector< float > & xAOD::MissingETAssociation_v1::f_trkpx ( )

protected

f_trkpy()

std::vector< float > & xAOD::MissingETAssociation_v1::f_trkpy ( )

protected

f_trkpz()

std::vector< float > & xAOD::MissingETAssociation_v1::f_trkpz ( )

protected

f_trksumpt()

std::vector< float > & xAOD::MissingETAssociation_v1::f_trksumpt ( )

protected

findCalIndex()

size_t xAOD::MissingETAssociation_v1::findCalIndex

(

MissingETBase::Types::bitmask_t

mask

)

const

Definition at line 281 of file MissingETAssociation_v1.cxx.

  {
    for (size_t ind = 0; ind < this->sizeCal(); ind++) if (mask==this->calkey()[ind]) return ind;
    return MissingETBase::Numerical::invalidIndex();
  }

findIndex()

size_t xAOD::MissingETAssociation_v1::findIndex

(

const IParticle *

pPart

)

const

Find index of given object in contributing object store.

The returned index is valid for the contributing object store and the parameter stores (index-parallel stores).

Returns

A valid index \( i \in \{ 0 \ldots N_{\rm objects} - 1 \} \), where \( N_{\rm objects} \) is the total number of contributing objects to the MET contribution. If the given object is not in the store with the requested status, MissingETBase::Numerical::invalidIndex() is returned.

This method makes use of a cache. If the pointer to the checked object is the same as the last one successfully searched for, the index is returned from a cached data word. If the pointer is not the same, xAOD::MissingETAssociation::findIndex(const IParticle*) is invoked. If this method finds the referenced object, the cache is updated and the valid index is returned. In case the object is not found, MissingETBase::Nummerical::invalidIndex() is returned.

Returns

Valid object index \( i = 0 \ldots N_{\rm objects} - 1 \) if object found in list, else MissingETBase::Numerical::invalidIndex().

Parameters

[in]	pPart	pointer to non-modifiable object
[in]	pPart	pointer to non-modifiable object in the list of contributing objects

Definition at line 266 of file MissingETAssociation_v1.cxx.

  {
    objlink_vector_t::const_iterator fLnk(this->objectLinks().begin());
    // FIXME: This is based on dereferencing the ElementLink, which is risky.
    while ( fLnk != this->objectLinks().end() ) {
      if((*fLnk).isValid()) {
        if(*(*fLnk) == pPart) break;
      }
      ++fLnk;
    }
    if ( fLnk != this->objectLinks().end() )
      return std::distance(this->objectLinks().begin(),fLnk);
    return MissingETBase::Numerical::invalidIndex();
  }

findTrkIndex()

size_t xAOD::MissingETAssociation_v1::findTrkIndex

(

MissingETBase::Types::bitmask_t

mask

)

const

Definition at line 287 of file MissingETAssociation_v1.cxx.

  {
    for (size_t ind = 0; ind < this->sizeTrk(); ind++) if (mask==this->trkkey()[ind]) return ind;
    return MissingETBase::Numerical::invalidIndex();
  }

getAlternateConstVec()

xAOD::JetFourMom_t xAOD::MissingETAssociation_v1::getAlternateConstVec

(

)

const

Definition at line 757 of file MissingETAssociation_v1.cxx.

  {
    xAOD::JetFourMom_t newvec;
    constvec_t newpt;
    size_t newptIndex = this->findIndex(this->refJet());
    if (newptIndex == MissingETBase::Numerical::invalidIndex()) return newvec;
    MissingETBase::Types::bitmask_t mask = (MissingETBase::Types::bitmask_t)1 << newptIndex;
    
    for (size_t iKey = 0; iKey < this->sizeCal(); iKey++) if (mask & this->calkey()[iKey]) newpt += this->calVec(iKey);
    newvec.SetPxPyPzE(newpt.cpx(),newpt.cpy(),newpt.cpz(),newpt.ce());
    return newvec; 
  }

getAuxIDs()

const SG::auxid_set_t & SG::AuxElement::getAuxIDs ( ) const

inherited

Return a set of identifiers for existing data items for this object.

If this object has a private or standalone store, then information from that will be returned. Otherwise, if this element is part of a container, then information for the container will be returned. Otherwise, return an empty set.

Definition at line 355 of file AuxElement.cxx.

{
#ifdef ATHCONTAINERS_R21_COMPAT
  if (havePrivateData())
    return m_container->getConstStore()->getAuxIDs();
  if (container())
    return container()->getAuxIDs();
  static const SG::auxid_set_t null_set;
  return null_set;
#else
  return ConstAuxElement::getAuxIDs();
#endif
}

getConstStore()

const SG::IConstAuxStore * SG::AuxElement::getConstStore ( ) const

inherited

Return the current store, as a const interface.

This will be non-zero if either a const or non-const store is associated with this object. This will fetch either a private or standalone store.

Definition at line 304 of file AuxElement.cxx.

{
  if (havePrivateData()) {
    return m_container->getConstStore();
  }
  return 0;
}

getDecorIDs()

const SG::auxid_set_t & SG::AuxElement::getDecorIDs ( ) const

inherited

Return a set of identifiers for decorations for this object.

   If this object has a private or standalone store, then information
   from that will be returned.  Otherwise, if this element
   is part of a container, then information for the container
   will be returned.  Otherwise, return an empty set.

Definition at line 378 of file AuxElement.cxx.

{
#ifdef ATHCONTAINERS_R21_COMPAT
  if (havePrivateData())
    return m_container->getConstStore()->getDecorIDs();
  if (container())
    return container()->getDecorIDs();
  static const SG::auxid_set_t null_set;
  return null_set;
#else
  return ConstAuxElement::getDecorIDs();
#endif
}

getStore()

SG::IAuxStore * SG::AuxElement::getStore ( ) const

inherited

Return the current store, as a non-const interface.

This will be non-zero if a non-const store is associated with this object. This will fetch either a private or standalone store.

Definition at line 319 of file AuxElement.cxx.

{
  if (havePrivateData()) {
#ifdef ATHCONTAINERS_R21_COMPAT
    SG::AuxVectorData* container_nc ATLAS_THREAD_SAFE = m_container;
#else
    SG::AuxVectorData* container_nc ATLAS_THREAD_SAFE = const_cast<SG::AuxVectorData*>(container());
#endif
    return container_nc->getStore();
  }
  return 0;
}

hadPrivateData()

bool SG::IAuxElement::hadPrivateData ( ) const

protectedinherited

True if this element had private data before it was added to its current container.

hasAlternateConstVec()

bool xAOD::MissingETAssociation_v1::hasAlternateConstVec

(

)

const

Definition at line 752 of file MissingETAssociation_v1.cxx.

  {
    return (!this->isMisc() && this->containsPhysics(this->refJet()));
  }

hasNonConstStore()

bool SG::AuxElement::hasNonConstStore ( ) const

inherited

Return true if this object has an associated non-const store.

This will be true for either a private or standalone store.

Definition at line 411 of file AuxElement.cxx.

{
  if (havePrivateData())
    return m_container->hasNonConstStore();
  return false;
}

hasOverlaps() [1/2]

bool xAOD::MissingETAssociation_v1::hasOverlaps	(	const MissingETAssociationHelper &	helper,
		const IParticle *	pPart,
		MissingETBase::UsageHandler::Policy	p = MissingETBase::UsageHandler::OnlyCluster ) const

Check if any selected particles overlap this one.

hasOverlaps() [2/2]

bool xAOD::MissingETAssociation_v1::hasOverlaps	(	const MissingETAssociationHelper &	helper,
		size_t	objIdx,
		MissingETBase::UsageHandler::Policy	p = MissingETBase::UsageHandler::OnlyCluster ) const

Check if any selected particles overlap this one.

Definition at line 717 of file MissingETAssociation_v1.cxx.

  {
    if ( objIdx == MissingETBase::Numerical::invalidIndex() ) return false;
    vector<size_t> indices = this->overlapIndices(objIdx);
    vector<unsigned char> types = this->overlapTypes(objIdx);
    for(size_t iOL=0; iOL<indices.size(); ++iOL) {
      if(helper.objSelected(this, indices[iOL])) {
        // printf("Test object %lu for overlaps: OL type %i\n",indices[iOL],(int)types[iOL]);
        switch(p) {
        case MissingETBase::UsageHandler::TrackCluster:      
          if((types[iOL] & 1<<xAOD::Type::CaloCluster) || (types[iOL] & 1<<xAOD::Type::TrackParticle)) {break;}
          else {continue;}
        case MissingETBase::UsageHandler::OnlyCluster:
          if(types[iOL] & 1<<xAOD::Type::CaloCluster) {break;}
          else {continue;}
        case MissingETBase::UsageHandler::OnlyTrack:
          if(types[iOL] & 1<<xAOD::Type::TrackParticle) {break;}
          else {continue;}
        case MissingETBase::UsageHandler::ParticleFlow:
          if(types[iOL] & 1<<xAOD::Type::ParticleFlow) {break;}
          else {continue;}
        case MissingETBase::UsageHandler::TruthParticle:
          if(types[iOL] & 1) {break;}
          else {continue;}
        case MissingETBase::UsageHandler::AllCalo:
          if(types[iOL] & ~(1<<xAOD::Type::TrackParticle)) {break;}
          else {continue;}
        default: continue;
        }
        return true;
      }
    }
    return false;
  }

hasStore()

bool SG::AuxElement::hasStore ( ) const

inherited

Return true if this object has an associated store.

This will be true for either a private or standalone store.

Definition at line 398 of file AuxElement.cxx.

{
  if (havePrivateData())
    return m_container->hasStore();
  return false;
}

havePrivateData()

bool SG::IAuxElement::havePrivateData ( ) const

protectedinherited

True if this element currently has private data.

identifyOverlaps() [1/3]

bool xAOD::MissingETAssociation_v1::identifyOverlaps

(

)

Loop over contributing objects to identify those that share constituents.

Definition at line 598 of file MissingETAssociation_v1.cxx.

  {
    using bitmask_t = MissingETBase::Types::bitmask_t;
    this->resetContrib();
    std::map<MissingETBase::Types::bitmask_t,MissingETBase::Types::constvec_t> trkOverlaps;
    std::map<MissingETBase::Types::bitmask_t,MissingETBase::Types::constvec_t> calOverlaps;
    std::map<ElementLink<IParticleContainer>,bitmask_t> objects;
    for(size_t iObj=0; iObj<this->objectLinks().size(); ++iObj) {
      const vector<ElementLink<IParticleContainer> >& myConst = m_objConstLinks[iObj];
      for (size_t iConst=0; iConst<myConst.size(); ++iConst) {
        objects[myConst[iConst]] |= static_cast<bitmask_t>(1) << iObj;
      }
    }
    for (const auto& objpair : objects) {
      const IParticle* obj = *objpair.first;
      MissingETBase::Types::bitmask_t bm = objpair.second;
      if (obj->type()==xAOD::Type::TrackParticle) trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
      else if (obj->type()==xAOD::Type::FlowElement) {
        const xAOD::FlowElement* fe = static_cast<const xAOD::FlowElement*>(obj);
        // Assume this FlowElement represents a PFO
        if(fe->isCharged()) {
          // apply cPFO weight if present, only for the inclusive PFO sum
          if (m_override.find(obj)!=m_override.end()) {
            calOverlaps[bm] += m_override[obj];
          } else {
            calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
          }
          trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
        } else {
          if (m_override.find(obj)!=m_override.end()) {
            calOverlaps[bm] += m_override[obj];
          } else {
            calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
          } // gets ignored otherwise?
        }
      }
      else if (obj->type()==xAOD::Type::ParticleFlow) {
        const PFO* pfo = static_cast<const PFO*>(obj);
        if(pfo->isCharged()) {
          // apply cPFO weight if present, only for the inclusive PFO sum
          if (m_override.find(obj)!=m_override.end()) {
            calOverlaps[bm] += m_override[obj];
          } else {
            calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
          }
          trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
        } else {
          if (m_override.find(obj)!=m_override.end()) {
            calOverlaps[bm] += m_override[obj];
          } else {
            calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
          } // gets ignored otherwise?
        }
      } else if(obj->type()==xAOD::Type::TruthParticle) {
        const TruthParticle* tp = static_cast<const TruthParticle*>(obj);
        if(fabs(tp->charge())>0.)
          trkOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
        if(!tp->isMuon())
          calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
      }
      else calOverlaps[bm] += MissingETBase::Types::constvec_t(*obj);
    }
    for (const auto& calpair : calOverlaps) {
      MissingETBase::Types::bitmask_t bm = calpair.first;
      MissingETBase::Types::constvec_t cv = calpair.second;
      this->addCalVec(bm,cv.cpx(),cv.cpy(),cv.cpz(),cv.ce(),cv.sumpt());
    }
    for (const auto& trkpair : trkOverlaps) {
      MissingETBase::Types::bitmask_t bm = trkpair.first;
      MissingETBase::Types::constvec_t cv = trkpair.second;
      this->addTrkVec(bm,cv.cpx(),cv.cpy(),cv.cpz(),cv.ce(),cv.sumpt());
    }
 
    bool foundOverlaps(false);
    for(size_t iObj=0; iObj<this->objectLinks().size(); ++iObj) {
      foundOverlaps |= identifyOverlaps(iObj);
    }
    return foundOverlaps;
  }

identifyOverlaps() [2/3]

bool xAOD::MissingETAssociation_v1::identifyOverlaps

(

const IParticle *

pPart

)

Search association for particles that share constituents with this one.

identifyOverlaps() [3/3]

bool xAOD::MissingETAssociation_v1::identifyOverlaps

(

size_t

objIdx

)

Search association for particles that share constituents with this one.

Definition at line 678 of file MissingETAssociation_v1.cxx.

  {
    if ( objIdx == MissingETBase::Numerical::invalidIndex() ) return false;
    // extract constituent list
    const vector<MissingETBase::Types::objlink_t >& myConst = m_objConstLinks[objIdx];
    // loop over subsequent objects in this association
    // (assume earlier ones have been tested)
    vector<size_t>& myOverlaps = f_overlapIndices()[objIdx];
    for(size_t iTargetObj=objIdx+1; iTargetObj<this->objectLinks().size(); ++iTargetObj) {
      const vector<MissingETBase::Types::objlink_t >& checkConst = m_objConstLinks[iTargetObj];
      bool overlapFound(false);
      unsigned char overlapTypes(0);
      // if we somehow already recorded an overlap for this one, skip
      for(vector<size_t>::const_iterator iOverlap=myOverlaps.begin();
          iOverlap!=myOverlaps.end() && !overlapFound; ++iOverlap) {
        overlapFound = (*iOverlap) == iTargetObj;
      }
      if(overlapFound) continue;
      // otherwise, compare constituents to check if any match
      for(const auto& mine : myConst) {
        for(const auto& target : checkConst) {
          overlapFound |= ( mine == target );
          if(mine == target) {
            if((*mine)->type()==xAOD::Type::TruthParticle) overlapTypes |= 1;
            else if((*mine)->type()==xAOD::Type::Other) overlapTypes |= 1 << xAOD::Type::NeutralParticle;
            else if((*mine)->type()==xAOD::Type::FlowElement) overlapTypes |= 1 << FEHelpers::signalToXAODType(static_cast<const xAOD::FlowElement&>(**mine));
            else overlapTypes |= 1 << (*mine)->type();
          }
        }
      }
      // record the overlap
      if(overlapFound) {
        this->addOverlap(objIdx,iTargetObj,overlapTypes);
        this->addOverlap(iTargetObj,objIdx,overlapTypes);
      }
    }
    return !overlapIndices(objIdx).empty();
  }

index()

size_t SG::IAuxElement::index ( ) const

inherited

Return the index of this element within its container.

Inherited from IAuxElement.

initCache()

void xAOD::MissingETAssociation_v1::initCache ( )

protected

initialise cache for overlap removal decisions

Definition at line 866 of file MissingETAssociation_v1.cxx.

  {
  
    m_objConstLinks.clear();
    m_objConstLinks.reserve(50);
  }

isAvailable()

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED bool SG::AuxElement::isAvailable ( const std::string & name, const std::string & clsname = "" ) const

inherited

Check if an aux variable is available for reading.

Parameters

name	Name of the aux variable.
clsname	The name of the associated class. May be blank.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

isAvailableWritable()

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED bool SG::AuxElement::isAvailableWritable ( const std::string & name, const std::string & clsname = "" )

inherited

Check if an aux variable is available for writing.

Parameters

name	Name of the aux variable.
clsname	The name of the associated class. May be blank.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

isAvailableWritableAsDecoration()

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED bool SG::AuxElement::isAvailableWritableAsDecoration ( const std::string & name, const std::string & clsname = "" ) const

inherited

Check if an aux variable is available for writing as a decoration.

Parameters

name	Name of the aux variable.
clsname	The name of the associated class. May be blank.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

isMisc()

bool xAOD::MissingETAssociation_v1::isMisc

(

)

const

Check if this association is a miscellaneous association.

jetLink()

const MissingETBase::Types::jetlink_t & xAOD::MissingETAssociation_v1::jetLink

(

)

const

Get the link to the reference jet.

jettrke()

float xAOD::MissingETAssociation_v1::jettrke

(

)

const

Get the vector \( E \) for a given object referenced by index.

jettrkpx()

float xAOD::MissingETAssociation_v1::jettrkpx

(

)

const

Get the vector \( P_{x} \) for a given object referenced by index.

jettrkpy()

float xAOD::MissingETAssociation_v1::jettrkpy

(

)

const

Get the vector \( P_{y} \) for a given object referenced by pointer.

jettrkpz()

float xAOD::MissingETAssociation_v1::jettrkpz

(

)

const

Get the vector \( P_{z} \) for a given object referenced by pointer.

jettrksumpt()

float xAOD::MissingETAssociation_v1::jettrksumpt

(

)

const

Get the sumpt for a given object referenced by index.

jetTrkVec()

constvec_t xAOD::MissingETAssociation_v1::jetTrkVec

(

)

const

Get track constituent vector for the reference jet.

Definition at line 568 of file MissingETAssociation_v1.cxx.

  { return constvec_t(this->jettrkpx(),this->jettrkpy(),this->jettrkpz(),this->jettrke(),this->jettrksumpt()); }

makePrivateStore() [1/3]

void SG::AuxElement::makePrivateStore ( )

inherited

Create a new (empty) private store for this object.

ExcBadPrivateStore will be thrown if this object is already associated with a store.

Definition at line 192 of file AuxElement.cxx.

{
  if (m_container) {
    throw SG::ExcBadPrivateStore ("store already exists");
  }
 
  m_container = new SG::AuxElementPrivateData;
  IAuxElement::setIndex (0);
  IAuxElement::setHavePrivateData();
}

makePrivateStore() [2/3]

template<class U1>

void SG::AuxElement::makePrivateStore ( const U1 & other, bool warnUnlocked = false )

inherited

Create a new private store for this object and copy aux data.

Parameters

other	The object from which aux data should be copied.
warnUnlocked	If true, then warn when we skip unlocked decorations.

ExcBadPrivateStore will be thrown if this object is already associated with a store.

If other is an object that has aux data, then those data will be copied; otherwise, nothing will be done.

makePrivateStore() [3/3]

template<class U1>

void SG::AuxElement::makePrivateStore ( const U1 * other, bool warnUnlocked = false )

inherited

Create a new private store for this object and copy aux data.

Parameters

other	The object from which aux data should be copied.
warnUnlocked	If true, then warn when we skip unlocked decorations.

ExcBadPrivateStore will be thrown if this object is already associated with a store.

If other is an object that has aux data, then those data will be copied; otherwise, nothing will be done.

makePrivateStore1() [1/2]

void SG::AuxElement::makePrivateStore1 ( const AuxElement * other, bool warnUnlocked )

privateinherited

Create a new private store for this object and copy aux data.

Parameters

other	The object from which aux data should be copied.
warnUnlocked	If true, then warn when we skip unlocked decorations.

ExcBadPrivateStore will be thrown if this object is already associated with a store.

This overload handles the case where other does have aux data.

Definition at line 565 of file AuxElement.cxx.

{
  makePrivateStore();
  if (other)
    this->copyAux (*other, warnUnlocked);
}

makePrivateStore1() [2/2]

void SG::AuxElement::makePrivateStore1 ( const void * other, bool warnUnlocked )

privateinherited

Create a new private store for this object and copy aux data.

Parameters

other	The object from which aux data should be copied.
warnUnlocked	If true, then warn when we skip unlocked decorations.

ExcBadPrivateStore will be thrown if this object is already associated with a store.

This overload handles the case where other does not have aux data.

noPrivateData()

bool SG::IAuxElement::noPrivateData ( ) const

protectedinherited

True if this element has no private data.

objectLinks()

const MissingETBase::Types::objlink_vector_t & xAOD::MissingETAssociation_v1::objectLinks

(

)

const

Get the vector of links to the contributing physics or signal objects.

objects() [1/3]

std::vector< const IParticle * > xAOD::MissingETAssociation_v1::objects

(

)

const

Access contributing objects.

Definition at line 503 of file MissingETAssociation_v1.cxx.

  { 
    vector<const IParticle*> pVec;
    for ( objlink_vector_t::const_iterator fLnk(this->objectLinks().begin()); fLnk != this->objectLinks().end(); ++fLnk) {pVec.push_back((*fLnk).isValid()?*(*fLnk):nullptr); }
    return pVec;
  }

objects() [2/3]

std::vector< const IParticle * > xAOD::MissingETAssociation_v1::objects	(	const std::vector< float > *&	calpxPtr,
		const std::vector< float > *&	calpyPtr,
		const std::vector< float > *&	calpzPtr,
		const std::vector< float > *&	calePtr,
		const std::vector< float > *&	calsumptPtr,
		const std::vector< float > *&	trkpxPtr,
		const std::vector< float > *&	trkpyPtr,
		const std::vector< float > *&	trkpzPtr,
		const std::vector< float > *&	trkePtr,
		const std::vector< float > *&	trksumptPtr ) const

Access contributing objects and retrieve constituent vectors.

Definition at line 522 of file MissingETAssociation_v1.cxx.

  {
    calpxPtr = &(this->calpx()); calpyPtr = &(this->calpy()); calpzPtr = &(this->calpz()); calePtr = &(this->cale()); calsumptPtr = &(this->calsumpt());
    trkpxPtr = &(this->trkpx()); trkpyPtr = &(this->trkpy()); trkpzPtr = &(this->trkpz()); trkePtr = &(this->trke()); trksumptPtr = &(this->trksumpt());
    return this->objects();
  }

objects() [3/3]

std::vector< const IParticle * > xAOD::MissingETAssociation_v1::objects	(	std::vector< ConstVec > &	calVecs,
		std::vector< ConstVec > &	trkVecs ) const

Access contributing objects and retrieve constituent vectors.

Definition at line 510 of file MissingETAssociation_v1.cxx.

  {
    size_t nEnt(this->objectLinks().size());
    vector<const IParticle*> pVec(nEnt,(const IParticle*)nullptr);
    calVecs.clear(); calVecs.resize(this->sizeCal(),constvec_t()); 
    trkVecs.clear(); trkVecs.resize(this->sizeTrk(),constvec_t()); 
    for ( size_t idx(0); idx < nEnt; ++idx ) pVec[idx] = *(this->objectLinks().at(idx));
    for ( size_t idx(0); idx < this->sizeCal(); idx++) calVecs[idx] = constvec_t(this->calpx(idx),this->calpy(idx),this->calpz(idx),this->cale(idx),this->calsumpt(idx));
    for ( size_t idx(0); idx < this->sizeTrk(); idx++) trkVecs[idx] = constvec_t(this->trkpx(idx),this->trkpy(idx),this->trkpz(idx),this->trke(idx),this->trksumpt(idx));
    return pVec;
  }

operator!=()

bool xAOD::MissingETAssociation_v1::operator!=

(

const MissingETAssociation_v1 &

contrib

)

const

Equality.

operator=()

MissingETAssociation_v1 & xAOD::MissingETAssociation_v1::operator=

(

const MissingETAssociation_v1 &

assocDescr

)

Definition at line 119 of file MissingETAssociation_v1.cxx.

  {
    if((&assocDescr) != this) { 
      f_isMisc() = assocDescr.isMisc();
      this->setJetLink(assocDescr.jetLink());
      this->setObjectLinks(assocDescr.objectLinks());
      this->setOverlaps(assocDescr.overlapIndices(),assocDescr.overlapTypes());
      this->setCalPx(assocDescr.calpx());
      this->setCalPy(assocDescr.calpy());
      this->setCalPz(assocDescr.calpz());
      this->setCalE(assocDescr.cale());  
      this->setCalSumpt(assocDescr.calsumpt());  
      this->setCalKey(assocDescr.calkey());
      this->setTrkPx(assocDescr.trkpx());
      this->setTrkPy(assocDescr.trkpy());
      this->setTrkPz(assocDescr.trkpz());
      this->setTrkE(assocDescr.trke());  
      this->setTrkSumpt(assocDescr.trksumpt());  
      this->setTrkKey(assocDescr.trkkey());  
      this->setJetTrkPx(assocDescr.jettrkpx());
      this->setJetTrkPy(assocDescr.jettrkpy());
      this->setJetTrkPz(assocDescr.jettrkpz());
      this->setJetTrkE(assocDescr.jettrke());
    }
    return  *this;
  }

operator==()

bool xAOD::MissingETAssociation_v1::operator==

(

const MissingETAssociation_v1 &

contrib

)

const

Definition at line 575 of file MissingETAssociation_v1.cxx.

  {
    // FIXME compare only jet link and number of contributing particles 
    return 
      this->jetLink() == assocDescr.jetLink()    &&
      this->size()    == assocDescr.size();
  }

overlapCalVec()

constvec_t xAOD::MissingETAssociation_v1::overlapCalVec

(

const MissingETAssociationHelper &

helper

)

const

Retrieve total cluster-based vector to be subtracted from the jet.

Definition at line 770 of file MissingETAssociation_v1.cxx.

  {
    constvec_t calvec;
    for (size_t iKey = 0; iKey < this->sizeCal(); iKey++) {
      bool selector = (helper.getObjSelectionFlags(this) & this->calkey()[iKey]) ? !this->isMisc() : this->isMisc();
      if (selector) calvec+=this->calVec(iKey);
    }
    return calvec;
  }

overlapIndices() [1/3]

const std::vector< std::vector< size_t > > & xAOD::MissingETAssociation_v1::overlapIndices

(

)

const

Get the list of object overlapIndices.

overlapIndices() [2/3]

std::vector< size_t > xAOD::MissingETAssociation_v1::overlapIndices

(

const IParticle *

pPart

)

const

Get the overlap indices for a given object referenced by pointer.

overlapIndices() [3/3]

std::vector< size_t > xAOD::MissingETAssociation_v1::overlapIndices

(

size_t

objIdx

)

const

Get the overlap indices for a given object referenced by index.

Definition at line 493 of file MissingETAssociation_v1.cxx.

  {
    return (objIdx != MissingETBase::Numerical::invalidIndex() && objIdx < this->size()) ? this->overlapIndices()[objIdx] : vector<size_t>(0);
  }

overlapTrkVec()

constvec_t xAOD::MissingETAssociation_v1::overlapTrkVec

(

const MissingETAssociationHelper &

helper

)

const

Retrieve total track-based vector to be subtracted from the jet.

Definition at line 780 of file MissingETAssociation_v1.cxx.

  {
    constvec_t trkvec;
    for (size_t iKey = 0; iKey < this->sizeTrk(); iKey++) {
      bool selector = (helper.getObjSelectionFlags(this) & this->trkkey()[iKey]) ? !this->isMisc() : this->isMisc();
      if (selector) trkvec+=ConstVec(this->trkpx()[iKey],this->trkpy()[iKey],this->trkpz()[iKey],this->trke()[iKey],this->trksumpt()[iKey]);
    }
    return trkvec;
  }

overlapTypes() [1/3]

const std::vector< std::vector< unsigned char > > & xAOD::MissingETAssociation_v1::overlapTypes

(

)

const

Get the list of object overlapTypes.

overlapTypes() [2/3]

std::vector< unsigned char > xAOD::MissingETAssociation_v1::overlapTypes

(

const IParticle *

pPart

)

const

Get the overlap types for a given object referenced by pointer.

overlapTypes() [3/3]

std::vector< unsigned char > xAOD::MissingETAssociation_v1::overlapTypes

(

size_t

objIdx

)

const

Get the overlap types for a given object referenced by index.

Definition at line 498 of file MissingETAssociation_v1.cxx.

  {
    return (objIdx != MissingETBase::Numerical::invalidIndex() && objIdx < this->size()) ? this->overlapTypes()[objIdx] : vector<unsigned char>(0);
  }

overrideMom()

std::map< const IParticle *, ConstVec > xAOD::MissingETAssociation_v1::overrideMom

(

)

Get override momenta.

refJet()

const Jet * xAOD::MissingETAssociation_v1::refJet

(

)

const

Access reference jet.

refJetContainer()

const JetContainer * xAOD::MissingETAssociation_v1::refJetContainer

(

)

const

Access reference jet container holding reference jet.

refJetIndex()

size_t xAOD::MissingETAssociation_v1::refJetIndex

(

)

const

Access index of reference jet in its container.

releasePrivateStore()

void SG::AuxElement::releasePrivateStore ( )

inherited

Release and free any private store associated with this object.

ExcBadPrivateStore will be thrown if this object does not have a private store.

Definition at line 210 of file AuxElement.cxx.

{
  if (hadPrivateData()) {
    // We had a private store, but it was released because this object
    // was added to a container.  Just forget about it.
    IAuxElement::setNoPrivateData();
    return;
  }
 
  if (!havePrivateData() ||
      !m_container ||
      typeid(*m_container) != typeid(AuxElementPrivateData))
  {
    throw SG::ExcBadPrivateStore ("no private store exists");
  }
 
  IAuxElement::setIndex (0);
  IAuxElement::setNoPrivateData();
  delete m_container;
  m_container = 0;
}

releasePrivateStoreForDtor()

void SG::AuxElement::releasePrivateStoreForDtor ( )

privateinherited

Out-of-line portion of destructor.

Delete a private store if we have one.

Definition at line 441 of file AuxElement.cxx.

{
#ifdef ATHCONTAINERS_R21_COMPAT
  if (havePrivateData()) {
    delete m_container;
  }
#else
  ConstAuxElement::releasePrivateStoreForDtor();
#endif
}

removeContrib() [1/3]

bool xAOD::MissingETAssociation_v1::removeContrib

(

)

Remove all contributions.

Definition at line 211 of file MissingETAssociation_v1.cxx.

  {
    if ( this->empty() ) { return false; }
    else 
      { size_t nEnt(this->size()); for  ( size_t objIdx(0); objIdx<nEnt; ++objIdx ) { this->f_removeContrib(objIdx); } return true; }
  }

removeContrib() [2/3]

bool xAOD::MissingETAssociation_v1::removeContrib

(

const IParticle *

pPart

)

Remove a contribution referenced by an object pointer.

removeContrib() [3/3]

bool xAOD::MissingETAssociation_v1::removeContrib

(

size_t

objIdx

)

Remove a contribution referenced by an index.

resetContrib() [1/3]

bool xAOD::MissingETAssociation_v1::resetContrib

(

)

Reset all contribution parameters.

Definition at line 247 of file MissingETAssociation_v1.cxx.

  {
    for (size_t idx = 0; idx < this->size(); idx++) this->f_overlapIndices()[idx].clear();
    for (size_t idx = 0; idx < this->size(); idx++) this->f_overlapTypes()[idx].clear();
    this->f_calpx().clear();
    this->f_calpy().clear();
    this->f_calpz().clear();
    this->f_cale().clear();
    this->f_calsumpt().clear();
    this->f_calkey().clear();
    this->f_trkpx().clear();
    this->f_trkpy().clear();
    this->f_trkpz().clear();
    this->f_trke().clear();
    this->f_trksumpt().clear();
    this->f_trkkey().clear();
    return true;
  }

resetContrib() [2/3]

bool xAOD::MissingETAssociation_v1::resetContrib

(

const IParticle *

pPart

)

Reset the contribution parameters of an object referenced by a pointer.

resetContrib() [3/3]

bool xAOD::MissingETAssociation_v1::resetContrib

(

size_t

objIdx

)

Reset the contribution parameters of an object referenced by an index.

Definition at line 241 of file MissingETAssociation_v1.cxx.

  {
    this->resetContrib();
    return true;
  }

setCalE() [1/2]

bool xAOD::MissingETAssociation_v1::setCalE

(

const std::vector< float > &

calevec

)

Set the vector of \( E \).

Definition at line 303 of file MissingETAssociation_v1.cxx.

  { this->f_cale().clear(); this->f_cale().insert(this->f_cale().end(),calevec.begin(),calevec.end()); return !this->f_cale().empty(); }

setCalE() [2/2]

bool xAOD::MissingETAssociation_v1::setCalE	(	size_t	keyIdx,
		float	cale )

Set calo constituent vector \( E \) for a given contributing object referenced by index.

Definition at line 331 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_cale().size() ) { this->f_cale()[keyIdx] = cale; return true; } else { return false; } }

setCalKey() [1/2]

bool xAOD::MissingETAssociation_v1::setCalKey

(

const std::vector< MissingETBase::Types::bitmask_t > &

calkeyvec

)

Set the vector of keys.

Definition at line 307 of file MissingETAssociation_v1.cxx.

  { this->f_calkey().clear(); this->f_calkey().insert(this->f_calkey().end(),calkeyvec.begin(),calkeyvec.end()); return !this->f_calkey().empty(); }

setCalKey() [2/2]

bool xAOD::MissingETAssociation_v1::setCalKey	(	size_t	keyIdx,
		MissingETBase::Types::bitmask_t	calkey )

Set calo key for a given contributing entry referenced by index.

Definition at line 335 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_calkey().size() ) { this->f_calkey()[keyIdx] = calkey; return true; } else { return false; } }

setCalPx() [1/2]

bool xAOD::MissingETAssociation_v1::setCalPx

(

const std::vector< float > &

calpxvec

)

Set the vector of \( P_{x} \).

Definition at line 297 of file MissingETAssociation_v1.cxx.

  { this->f_calpx().clear(); this->f_calpx().insert(this->f_calpx().end(),calpxvec.begin(),calpxvec.end()); return !this->f_calpx().empty(); }

setCalPx() [2/2]

bool xAOD::MissingETAssociation_v1::setCalPx	(	size_t	keyIdx,
		float	calpx )

Set calo constituent vector \( P_{x} \) for a given contributing object referenced by index.

Definition at line 325 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_calpx().size() ) { this->f_calpx()[keyIdx] = calpx; return true; } else { return false; } }

setCalPy() [1/2]

bool xAOD::MissingETAssociation_v1::setCalPy

(

const std::vector< float > &

calpyvec

)

Set the vector of \( P_{y} \).

Definition at line 299 of file MissingETAssociation_v1.cxx.

  { this->f_calpy().clear(); this->f_calpy().insert(this->f_calpy().end(),calpyvec.begin(),calpyvec.end()); return !this->f_calpy().empty(); }

setCalPy() [2/2]

bool xAOD::MissingETAssociation_v1::setCalPy	(	size_t	keyIdx,
		float	calpy )

Set calo constituent vector \( P_{y} \) for a given contributing object referenced by index.

Definition at line 327 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_calpy().size() ) { this->f_calpy()[keyIdx] = calpy; return true; } else { return false; } }

setCalPz() [1/2]

bool xAOD::MissingETAssociation_v1::setCalPz

(

const std::vector< float > &

calpzvec

)

Set the vector of \( P_{z} \).

Definition at line 301 of file MissingETAssociation_v1.cxx.

  { this->f_calpz().clear(); this->f_calpz().insert(this->f_calpz().end(),calpzvec.begin(),calpzvec.end()); return !this->f_calpz().empty(); }

setCalPz() [2/2]

bool xAOD::MissingETAssociation_v1::setCalPz	(	size_t	keyIdx,
		float	calpz )

Set calo constituent vector \( P_{z} \) for a given contributing object referenced by index.

Definition at line 329 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_calpz().size() ) { this->f_calpz()[keyIdx] = calpz; return true; } else { return false; } }

setCalSumpt() [1/2]

bool xAOD::MissingETAssociation_v1::setCalSumpt

(

const std::vector< float > &

calsumptvec

)

Set the vector of sumpt.

Definition at line 305 of file MissingETAssociation_v1.cxx.

  { this->f_calsumpt().clear(); this->f_calsumpt().insert(this->f_calsumpt().end(),calsumptvec.begin(),calsumptvec.end()); return !this->f_calsumpt().empty(); }

setCalSumpt() [2/2]

bool xAOD::MissingETAssociation_v1::setCalSumpt	(	size_t	keyIdx,
		float	calsumpt )

Set calo constituent sumpt for a given contributing object referenced by index.

Definition at line 333 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_calsumpt().size() ) { this->f_calsumpt()[keyIdx] = calsumpt; return true; } else { return false; } }

setCalVec() [1/2]

bool xAOD::MissingETAssociation_v1::setCalVec	(	size_t	keyIdx,
		const ConstVec &	cvec = ConstVec() )

Set the calo constituent vector of an object contribution referenced by index.

setCalVec() [2/2]

bool xAOD::MissingETAssociation_v1::setCalVec	(	size_t	keyIdx,
		float	calpx,
		float	calpy,
		float	calpz,
		float	ce,
		float	sumpt )

Set the calo constituent vectors of an object contribution referenced by index.

Definition at line 337 of file MissingETAssociation_v1.cxx.

  {
    if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_cale().size() ) {
      this->f_calpx()[keyIdx] = calpx;  this->f_calpy()[keyIdx] = calpy;
      this->f_calpz()[keyIdx] = calpz;  this->f_cale()[keyIdx] = cale;
      this->f_calsumpt()[keyIdx] = sumpt; return true;
    } else { return false; }
  }

setConstStore()

void SG::AuxElement::setConstStore ( const SG::IConstAuxStore * store )

inherited

Synonym for setStore with IConstAuxStore.

Parameters

store

The new store.

setHadPrivateData()

void SG::IAuxElement::setHadPrivateData ( )

privateinherited

Record that this element used to have private data.

setHavePrivateData()

void SG::IAuxElement::setHavePrivateData ( )

privateinherited

Record that this element currently has private data.

setIndex()

void SG::AuxElement::setIndex ( size_t index, SG::AuxVectorData * container )

privateinherited

Set the index/container for this element.

Parameters

index	The index of this object within the container.
container	The container holding this object. May be null if this object is being removed from a container.

Usually this simply sets the index and container members of this object. However, in the case where this object has an associated private store, then we need to deal with releasing the store if the object is being added to a container, or making a new store if the object is being removed from a container.

setIndexPrivate()

bool SG::AuxElement::setIndexPrivate ( size_t index, SG::AuxVectorData * container )

privateinherited

Set the index/container for this element.

Parameters

index	The index of this object within the container.
container	The container holding this object. May be null if this object is being removed from a container.

This is called from setIndex when we have a private store to deal with.

Definition at line 505 of file AuxElement.cxx.

{
#ifdef ATHCONTAINERS_R21_COMPAT
  if (hadPrivateData()) {
    // We had a private store, but it was released because we were added
    // to a container.
 
    if (container == 0) {
      // We're being moved out of the container.  Make a new private
      // store, copy the data, and switch to it.
      auto privateData = new SG::AuxElementPrivateData;
      AuxElement to (privateData, 0);
      to.copyAux (*this);
      IAuxElement::setIndex (0);
      IAuxElement::setHavePrivateData();
      m_container = privateData;
      return true;
    }
  }
  else if (havePrivateData() &&
           typeid(*m_container) == typeid(AuxElementPrivateData))
  {
    // We currently have a private store.
 
    if (container != 0 && container != m_container) {
      // We're being added to a container.
      // Aux data has already been copied.
      // Release private store.
      IAuxElement::setIndex (index);
      IAuxElement::setHadPrivateData();
      delete m_container;
      m_container = container;
      return false;
    }
  }
  else {
    // We have a standalone store.
    throw SG::ExcBadPrivateStore ("Attempt to add/remove a standalone object "
                                  "from a container.");
  }
 
  IAuxElement::setIndex (index);
  m_container = container;
  return false;
#else
  return ConstAuxElement::setIndexPrivate (index, container);
#endif
}

setJetLink()

bool xAOD::MissingETAssociation_v1::setJetLink

(

const MissingETBase::Types::jetlink_t &

jetLnk

)

Set the link to the reference jet.

Definition at line 448 of file MissingETAssociation_v1.cxx.

  {
    bool wasSet(this->f_jetLink().getStorableObjectPointer() != nullptr);
    this->f_jetLink() = jetLnk;
    return wasSet;
  }

setJetTrkE()

void xAOD::MissingETAssociation_v1::setJetTrkE

(

float

e

)

Set track constituent vector \( E \) for the reference jet.

Definition at line 400 of file MissingETAssociation_v1.cxx.

  { this->f_jettrke() = e; }

setJetTrkPx()

void xAOD::MissingETAssociation_v1::setJetTrkPx

(

float

px

)

Set track constituent vector \( P_{x} \) for the reference jet.

Definition at line 394 of file MissingETAssociation_v1.cxx.

  { this->f_jettrkpx() = px; }

setJetTrkPy()

void xAOD::MissingETAssociation_v1::setJetTrkPy

(

float

py

)

Set track constituent vector \( P_{y} \) for the reference jet.

Definition at line 396 of file MissingETAssociation_v1.cxx.

  { this->f_jettrkpy() = py; }

setJetTrkPz()

void xAOD::MissingETAssociation_v1::setJetTrkPz

(

float

pz

)

Set track constituent vector \( P_{z} \) for the reference jet.

Definition at line 398 of file MissingETAssociation_v1.cxx.

  { this->f_jettrkpz() = pz; }

setJetTrkSumpt()

void xAOD::MissingETAssociation_v1::setJetTrkSumpt

(

float

sumpt

)

Set track constituent vector \( E \) for the reference jet.

Definition at line 402 of file MissingETAssociation_v1.cxx.

  { this->f_jettrksumpt() = sumpt; }

setJetTrkVec() [1/2]

void xAOD::MissingETAssociation_v1::setJetTrkVec

(

const ConstVec &

cvec = ConstVec()

)

Set the track constituent vector for the reference jet.

setJetTrkVec() [2/2]

void xAOD::MissingETAssociation_v1::setJetTrkVec	(	float	px,
		float	py,
		float	pz,
		float	ce,
		float	sumpt )

Set the track constituent vector for the reference jet.

Definition at line 404 of file MissingETAssociation_v1.cxx.

  {
    this->f_jettrkpx() = px;  this->f_jettrkpy() = py;
    this->f_jettrkpz() = pz;  this->f_jettrke() = e; 
    this->f_jettrksumpt() = sumpt; 
  }

setNonConstStore()

void SG::AuxElement::setNonConstStore ( SG::IAuxStore * store )

inherited

Synonym for setStore with IAuxStore.

Parameters

store

The new store.

setNoPrivateData()

void SG::IAuxElement::setNoPrivateData ( )

privateinherited

Record that this element does not have private data.

setObjectLinks()

bool xAOD::MissingETAssociation_v1::setObjectLinks

(

const MissingETBase::Types::objlink_vector_t &

objLnks

)

Set the vector of links to the contributing physics or signal objects.

Definition at line 455 of file MissingETAssociation_v1.cxx.

  { 
    bool wasSet(!this->f_objectLinks().empty()); 
    if ( wasSet ) {  this->f_objectLinks().clear(); this->f_objectLinks().insert(this->f_objectLinks().end(),objLnks.begin(),objLnks.end()); }
    return wasSet;
  }

setOverlaps() [1/3]

bool xAOD::MissingETAssociation_v1::setOverlaps	(	const IParticle *	pPart,
		const std::vector< size_t > &	overlapIndices,
		const std::vector< unsigned char > &	overlapTypes )

Set overlap indices and types for a given contributing object referenced by pointer.

setOverlaps() [2/3]

bool xAOD::MissingETAssociation_v1::setOverlaps	(	const std::vector< std::vector< size_t > > &	overlapIndices,
		const std::vector< std::vector< unsigned char > > &	overlapTypes )

Set the vector of overlap indices and types.

Definition at line 418 of file MissingETAssociation_v1.cxx.

  {
    this->f_overlapIndices().clear(); this->f_overlapIndices().insert(this->f_overlapIndices().end(),overlapIndexVector.begin(),overlapIndexVector.end());
    this->f_overlapTypes().clear(); this->f_overlapTypes().insert(this->f_overlapTypes().end(),overlapTypeVector.begin(),overlapTypeVector.end());
    return !this->f_overlapIndices().empty();
  }

setOverlaps() [3/3]

bool xAOD::MissingETAssociation_v1::setOverlaps	(	size_t	objIdx,
		const std::vector< size_t > &	overlapIndices,
		const std::vector< unsigned char > &	overlapTypes )

Set overlap indices and types for a given contributing object referenced by index.

Definition at line 424 of file MissingETAssociation_v1.cxx.

  {
    if ( objIdx != MissingETBase::Numerical::invalidIndex() && objIdx < this->f_overlapIndices().size() ) {
      this->f_overlapIndices()[objIdx] = overlapIndices;
      this->f_overlapTypes()[objIdx] = overlapTypes;
      return true; 
    } else { return false; }
  }

setOverrideMom()

void xAOD::MissingETAssociation_v1::setOverrideMom

(

const std::map< const IParticle *, ConstVec > &

pOverride

)

Set override momenta.

setRefJet() [1/2]

bool xAOD::MissingETAssociation_v1::setRefJet

(

const Jet *

pJet

)

Set reference jet by object pointer reference.

Definition at line 434 of file MissingETAssociation_v1.cxx.

  { 
    bool wasSet(this->f_jetLink().getStorableObjectPointer() != nullptr);
    f_setObject<Jet,MissingETBase::Types::jetlink_t>(pJet,this->f_jetLink());
    return wasSet;
  }

setRefJet() [2/2]

bool xAOD::MissingETAssociation_v1::setRefJet	(	const JetContainer *	pJetCont,
		size_t	pJetIdx )

Set reference jet by container pointer and index reference.

Definition at line 441 of file MissingETAssociation_v1.cxx.

  {
    bool wasSet(this->f_jetLink().getStorableObjectPointer() != nullptr);
    this->f_jetLink().toIndexedElement(*pJetCont,pJetIdx);
    return wasSet;
  }

setStore() [1/3]

void SG::AuxElement::setStore ( const DataLink< SG::IConstAuxStore > & store )

inherited

Set the store associated with this object.

Parameters

store

The new store.

If store is nonzero, this adds a standalone store to the object. The object must not be in a container and must not have a private store. If store is zero, this removes a standalone store.

Parameters

store

Link to the new store.

Definition at line 269 of file AuxElement.cxx.

{
  AuxElementStandaloneData* data = setStore1 (store);
  if (store)
    data->setStore (store);
}

setStore() [2/3]

void SG::AuxElement::setStore ( const SG::IConstAuxStore * store )

inherited

Set the store associated with this object.

Parameters

store

The new store.

If store is nonzero, this adds a standalone store to the object. The object must not be in a container and must not have a private store. If store is zero, this removes a standalone store.

Definition at line 241 of file AuxElement.cxx.

{
  AuxElementStandaloneData* data = setStore1 (store);
  if (store)
    data->setStore (store);
}

setStore() [3/3]

void SG::AuxElement::setStore ( SG::IAuxStore * store )

inherited

Set the store associated with this object.

Parameters

store

The new store.

If store is nonzero, this adds a standalone store to the object. The object must not be in a container and must not have a private store. If store is zero, this removes a standalone store.

Definition at line 257 of file AuxElement.cxx.

{
  AuxElementStandaloneData* data = setStore1 (store);
  if (store)
    data->setStore (store);
}

setStore1()

AuxElementStandaloneData * SG::AuxElement::setStore1 ( const SG::IConstAuxStore * store )

privateinherited

Set the store associated with this object.

Parameters

store

The new store.

Helper for setStore. Creates the AuxElementStandaloneData object if needed and returns it.

Parameters

store

The new store.

Helper for setStore. Creates the @x AuxElementStandaloneData object if needed and returns it.

Definition at line 461 of file AuxElement.cxx.

{
  if (store) {
    // Want this object be standalone.
    if (!m_container) {
      // Not in a container (and no private store).  Make a new object.
      AuxElementStandaloneData* data = new AuxElementStandaloneData;
      IAuxElement::setHavePrivateData();
      m_container = data;
      return data;
    }
    if (usingStandaloneStore()) {
      // Standalone --- return existing object.
      return static_cast<AuxElementStandaloneData*> (container());
    }
    // Otherwise, it's an error.
    throw ExcBadPrivateStore ("Attempt to attach a standalone store to an "
                              "object in a container or with a private store.");
  }
 
  else {
    // Getting rid of a standalone store.
    if (usingStandaloneStore()) {
      IAuxElement::setNoPrivateData();
      delete m_container;
      m_container = 0;
    }
    else if (m_container != 0)
      throw ExcBadPrivateStore ("Attempt to remove a standalone store from an "
                                "object in a container or with a private store.");
    return 0;
  }
}

setTrkE() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkE

(

const std::vector< float > &

trkevec

)

Set the vector of \( E \).

Definition at line 316 of file MissingETAssociation_v1.cxx.

  { this->f_trke().clear(); this->f_trke().insert(this->f_trke().end(),trkevec.begin(),trkevec.end()); return !this->f_trke().empty(); }

setTrkE() [2/2]

bool xAOD::MissingETAssociation_v1::setTrkE	(	size_t	keyIdx,
		float	trke )

Set track constituent vector \( E \) for a given contributing object referenced by index.

Definition at line 365 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trke().size() ) { this->f_trke()[keyIdx] = trke; return true; } else { return false; } }

setTrkKey() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkKey

(

const std::vector< MissingETBase::Types::bitmask_t > &

trkkeyvec

)

Set the vector of keys.

Definition at line 320 of file MissingETAssociation_v1.cxx.

  { this->f_trkkey().clear(); this->f_trkkey().insert(this->f_trkkey().end(),trkkeyvec.begin(),trkkeyvec.end()); return !this->f_trkkey().empty(); }

setTrkKey() [2/2]

bool xAOD::MissingETAssociation_v1::setTrkKey	(	size_t	keyIdx,
		MissingETBase::Types::bitmask_t	trkkey )

Set trk key for a given contributing entry referenced by index.

Definition at line 369 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trkkey().size() ) { this->f_trkkey()[keyIdx] = trkkey; return true; } else { return false; } }

setTrkPx() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkPx

(

const std::vector< float > &

trkpxvec

)

Set the vector of \( P_{x} \).

Definition at line 310 of file MissingETAssociation_v1.cxx.

  { this->f_trkpx().clear(); this->f_trkpx().insert(this->f_trkpx().end(),trkpxvec.begin(),trkpxvec.end()); return !this->f_trkpx().empty(); }

setTrkPx() [2/2]

bool xAOD::MissingETAssociation_v1::setTrkPx	(	size_t	keyIdx,
		float	trkpx )

Set track constituent vector \( P_{x} \) for a given contributing object referenced by index.

Definition at line 359 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trkpx().size() ) { this->f_trkpx()[keyIdx] = trkpx; return true; } else { return false; } }

setTrkPy() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkPy

(

const std::vector< float > &

trkpyvec

)

Set the vector of \( P_{y} \).

Definition at line 312 of file MissingETAssociation_v1.cxx.

  { this->f_trkpy().clear(); this->f_trkpy().insert(this->f_trkpy().end(),trkpyvec.begin(),trkpyvec.end()); return !this->f_trkpy().empty(); }

setTrkPy() [2/2]

bool xAOD::MissingETAssociation_v1::setTrkPy	(	size_t	keyIdx,
		float	trkpy )

Set track constituent vector \( P_{y} \) for a given contributing object referenced by index.

Definition at line 361 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trkpy().size() ) { this->f_trkpy()[keyIdx] = trkpy; return true; } else { return false; } }

setTrkPz() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkPz

(

const std::vector< float > &

trkpzvec

)

Set the vector of \( P_{z} \).

Definition at line 314 of file MissingETAssociation_v1.cxx.

  { this->f_trkpz().clear(); this->f_trkpz().insert(this->f_trkpz().end(),trkpzvec.begin(),trkpzvec.end()); return !this->f_trkpz().empty(); }

setTrkPz() [2/2]

bool xAOD::MissingETAssociation_v1::setTrkPz	(	size_t	keyIdx,
		float	trkpz )

Set track constituent vector \( P_{z} \) for a given contributing object referenced by index.

Definition at line 363 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trkpz().size() ) { this->f_trkpz()[keyIdx] = trkpz; return true; } else { return false; } }

setTrkSumpt() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkSumpt

(

const std::vector< float > &

trksumptvec

)

Set the vector of \( E \).

Definition at line 318 of file MissingETAssociation_v1.cxx.

  { this->f_trksumpt().clear(); this->f_trksumpt().insert(this->f_trksumpt().end(),trksumptvec.begin(),trksumptvec.end()); return !this->f_trksumpt().empty(); }

setTrkSumpt() [2/2]

bool xAOD::MissingETAssociation_v1::setTrkSumpt	(	size_t	keyIdx,
		float	trksumpt )

Set track constituent vector \( E \) for a given contributing object referenced by index.

Definition at line 367 of file MissingETAssociation_v1.cxx.

  { if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trksumpt().size() ) { this->f_trksumpt()[keyIdx] = trksumpt; return true; } else { return false; } }

setTrkVec() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkVec	(	size_t	keyIdx,
		const ConstVec &	cvec = ConstVec() )

Set the track constituent vector of an object contribution referenced by index.

setTrkVec() [2/2]

bool xAOD::MissingETAssociation_v1::setTrkVec	(	size_t	keyIdx,
		float	trkpx,
		float	trkpy,
		float	trkpz,
		float	trke,
		float	sumpt )

Set the track constituent vectors of an object contribution referenced by index.

Definition at line 371 of file MissingETAssociation_v1.cxx.

  { 
    if ( keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->f_trke().size() ) {
      this->f_trkpx()[keyIdx] = trkpx;  this->f_trkpy()[keyIdx] = trkpy;
      this->f_trkpz()[keyIdx] = trkpz;  this->f_trke()[keyIdx] = trke;
      this->f_trksumpt()[keyIdx] = sumpt; return true; 
    } else { return false; }
  }

size()

size_t xAOD::MissingETAssociation_v1::size

(

)

const

Update all internally used ElementLink instances.

Note

[Deprecated] This method scans the full list of contributing objects. It invokes MissingETAssociation_v1::updateJetlink internally.

[Deprecated] Update link to reference jet only

sizeCal()

size_t xAOD::MissingETAssociation_v1::sizeCal

(

)

const

sizeTrk()

size_t xAOD::MissingETAssociation_v1::sizeTrk

(

)

const

testPolicy() [1/2]

bool xAOD::MissingETAssociation_v1::testPolicy ( const xAOD::IParticle & part, MissingETBase::UsageHandler::Policy p )

static

Definition at line 873 of file MissingETAssociation_v1.cxx.

                                                                                                       {
    xAOD::Type::ObjectType objType = part.type();
    if(objType == xAOD::Type::FlowElement) objType = FEHelpers::signalToXAODType(static_cast<const xAOD::FlowElement&>(part));
    return testPolicy(objType, p);
  }

testPolicy() [2/2]

bool xAOD::MissingETAssociation_v1::testPolicy ( xAOD::Type::ObjectType type, MissingETBase::UsageHandler::Policy p )

staticprotected

Definition at line 879 of file MissingETAssociation_v1.cxx.

                                                                                                     {
    switch(p) {
    case MissingETBase::UsageHandler::TrackCluster:      
      return type==xAOD::Type::CaloCluster
          || type==xAOD::Type::TrackParticle;
    case MissingETBase::UsageHandler::OnlyCluster:
      return type==xAOD::Type::CaloCluster;
    case MissingETBase::UsageHandler::OnlyTrack:
      return type==xAOD::Type::TrackParticle;
    case MissingETBase::UsageHandler::ParticleFlow:
      return type==xAOD::Type::ParticleFlow;
    case MissingETBase::UsageHandler::AllCalo:
      return type!=xAOD::Type::TrackParticle;
    default: break;
    }
    return false;
  }

trackIndices()

bool SG::AuxElement::trackIndices ( ) const

inherited

Return true if index tracking is enabled for this object.

Always returns true. Included here to be consistent with AuxVectorBase when standalone objects may be used as template parameters.

trke() [1/2]

const std::vector< float > & xAOD::MissingETAssociation_v1::trke

(

)

const

Get the vector of \( E \).

trke() [2/2]

float xAOD::MissingETAssociation_v1::trke

(

size_t

keyIdx

)

const

Get the vector \( E \) for a given object referenced by index.

Definition at line 486 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trke()[keyIdx] : MissingETBase::Numerical::ceError(); }

trkkey() [1/2]

const std::vector< MissingETBase::Types::bitmask_t > & xAOD::MissingETAssociation_v1::trkkey

(

)

const

Get the vector of trk keys.

trkkey() [2/2]

MissingETBase::Types::bitmask_t xAOD::MissingETAssociation_v1::trkkey

(

size_t

keyIdx

)

const

Get the key for a given entry referenced by index.

Definition at line 490 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trkkey()[keyIdx] : MissingETBase::Numerical::invalidIndex(); }

trkpx() [1/2]

const std::vector< float > & xAOD::MissingETAssociation_v1::trkpx

(

)

const

Get the vector of \( P_{x} \).

trkpx() [2/2]

float xAOD::MissingETAssociation_v1::trkpx

(

size_t

keyIdx

)

const

Get the vector \( P_{x} \) for a given object referenced by index.

Definition at line 480 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trkpx()[keyIdx] : MissingETBase::Numerical::cpxError(); }

trkpy() [1/2]

const std::vector< float > & xAOD::MissingETAssociation_v1::trkpy

(

)

const

Get the vector of \( P_{y} \).

trkpy() [2/2]

float xAOD::MissingETAssociation_v1::trkpy

(

size_t

keyIdx

)

const

Get the vector \( P_{y} \) for a given object referenced by index.

Definition at line 482 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trkpy()[keyIdx] : MissingETBase::Numerical::cpyError(); }

trkpz() [1/2]

const std::vector< float > & xAOD::MissingETAssociation_v1::trkpz

(

)

const

Get the vector of \( P_{z} \).

trkpz() [2/2]

float xAOD::MissingETAssociation_v1::trkpz

(

size_t

keyIdx

)

const

Get the vector \( P_{z} \) for a given object referenced by index.

Definition at line 484 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trkpz()[keyIdx] : MissingETBase::Numerical::cpzError(); }

trksumpt() [1/2]

const std::vector< float > & xAOD::MissingETAssociation_v1::trksumpt

(

)

const

Get the vector of \( E \).

trksumpt() [2/2]

float xAOD::MissingETAssociation_v1::trksumpt

(

size_t

keyIdx

)

const

Get the vector \( E \) for a given object referenced by index.

Definition at line 488 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() ? this->trksumpt()[keyIdx] : MissingETBase::Numerical::sumptError(); }

trkVec() [1/2]

MissingETAssociation_v1::ConstVec xAOD::MissingETAssociation_v1::trkVec

(

const IParticle *

pPart

)

const

Get track constituent vector for a given object.

Definition at line 548 of file MissingETAssociation_v1.cxx.

  {
    MissingETBase::Types::constvec_t totalvec;
    for (size_t iKey = 0; iKey < this->sizeTrk(); iKey++) {
      if (this->trkkey(iKey) & getObjMask(this->findIndex(pPart)))
        totalvec+=this->trkVec(iKey);
    }
    return totalvec;
  }

trkVec() [2/2]

constvec_t xAOD::MissingETAssociation_v1::trkVec

(

size_t

keyIdx

)

const

Get track constituent vector for a given entry (index) in the contributing object list.

Definition at line 563 of file MissingETAssociation_v1.cxx.

  { return keyIdx != MissingETBase::Numerical::invalidIndex() && keyIdx < this->sizeTrk() 
      ? constvec_t(this->trkpx(keyIdx),this->trkpy(keyIdx),this->trkpz(keyIdx),this->trke(keyIdx),this->trksumpt(keyIdx)) 
      : constvec_t(MissingETBase::Numerical::cpxError(),MissingETBase::Numerical::cpyError(),MissingETBase::Numerical::cpzError(),MissingETBase::Numerical::ceError(),MissingETBase::Numerical::sumptError()); }

usingPrivateStore()

bool SG::AuxElement::usingPrivateStore ( ) const

inherited

Test to see if this object is currently using a private store.

Definition at line 280 of file AuxElement.cxx.

{
  return havePrivateData() && 
    typeid(*m_container) == typeid(AuxElementPrivateData);
}

usingStandaloneStore()

bool SG::AuxElement::usingStandaloneStore ( ) const

inherited

Test to see if this object is currently using a standalone store.

Test to see if this object is currently using a private store.

Definition at line 290 of file AuxElement.cxx.

{
  return havePrivateData() &&
    typeid(*m_container) == typeid(AuxElementStandaloneData);
}

Member Data Documentation

m_acc_cale

const SG::AuxElement::Accessor< std::vector< float > > xAOD::MissingETAssociation_v1::m_acc_cale

staticprivate

Definition at line 431 of file MissingETAssociation_v1.h.

m_acc_calpx

const SG::AuxElement::Accessor< std::vector< float > > xAOD::MissingETAssociation_v1::m_acc_calpx

staticprivate

Definition at line 428 of file MissingETAssociation_v1.h.

m_acc_calpy

const SG::AuxElement::Accessor< std::vector< float > > xAOD::MissingETAssociation_v1::m_acc_calpy

staticprivate

Definition at line 429 of file MissingETAssociation_v1.h.

m_acc_calpz

const SG::AuxElement::Accessor< std::vector< float > > xAOD::MissingETAssociation_v1::m_acc_calpz

staticprivate

Definition at line 430 of file MissingETAssociation_v1.h.

m_acc_calsumpt

const SG::AuxElement::Accessor< std::vector< float > > xAOD::MissingETAssociation_v1::m_acc_calsumpt

staticprivate

Definition at line 432 of file MissingETAssociation_v1.h.

m_acc_jettrke

const SG::AuxElement::Accessor< float > xAOD::MissingETAssociation_v1::m_acc_jettrke

staticprivate

Definition at line 443 of file MissingETAssociation_v1.h.

m_acc_jettrkpx

const SG::AuxElement::Accessor< float > xAOD::MissingETAssociation_v1::m_acc_jettrkpx

staticprivate

Definition at line 440 of file MissingETAssociation_v1.h.

m_acc_jettrkpy

const SG::AuxElement::Accessor< float > xAOD::MissingETAssociation_v1::m_acc_jettrkpy

staticprivate

Definition at line 441 of file MissingETAssociation_v1.h.

m_acc_jettrkpz

const SG::AuxElement::Accessor< float > xAOD::MissingETAssociation_v1::m_acc_jettrkpz

staticprivate

Definition at line 442 of file MissingETAssociation_v1.h.

m_acc_jettrksumpt

const SG::AuxElement::Accessor< float > xAOD::MissingETAssociation_v1::m_acc_jettrksumpt

staticprivate

Definition at line 444 of file MissingETAssociation_v1.h.

m_acc_trke

const SG::AuxElement::Accessor< std::vector< float > > xAOD::MissingETAssociation_v1::m_acc_trke

staticprivate

Definition at line 437 of file MissingETAssociation_v1.h.

m_acc_trkpx

const SG::AuxElement::Accessor< std::vector< float > > xAOD::MissingETAssociation_v1::m_acc_trkpx

staticprivate

Definition at line 434 of file MissingETAssociation_v1.h.

m_acc_trkpy

const SG::AuxElement::Accessor< std::vector< float > > xAOD::MissingETAssociation_v1::m_acc_trkpy

staticprivate

Definition at line 435 of file MissingETAssociation_v1.h.

m_acc_trkpz

const SG::AuxElement::Accessor< std::vector< float > > xAOD::MissingETAssociation_v1::m_acc_trkpz

staticprivate

Definition at line 436 of file MissingETAssociation_v1.h.

m_acc_trksumpt

const SG::AuxElement::Accessor< std::vector< float > > xAOD::MissingETAssociation_v1::m_acc_trksumpt

staticprivate

Definition at line 438 of file MissingETAssociation_v1.h.

m_container

const SG::AuxVectorData* SG::ConstAuxElement::m_container

privateinherited

The container of which this object is an element.

Should be null if this object is not within a container, except that it may also point at a private store.

Definition at line 335 of file AuxElement.h.

m_index

size_t SG::IAuxElement::m_index

privateinherited

The index of this element within its container.

Should be 0 if this object is not within a container.

Definition at line 128 of file IAuxElement.h.

m_objConstLinks

std::vector<std::vector<ElementLink<IParticleContainer> > > xAOD::MissingETAssociation_v1::m_objConstLinks

protected

Cache object constituents for overlap-finding.

Definition at line 423 of file MissingETAssociation_v1.h.

m_override

std::map<const IParticle*,ConstVec> xAOD::MissingETAssociation_v1::m_override

private

Definition at line 426 of file MissingETAssociation_v1.h.

m_privateStoreState

PrivateStoreState SG::IAuxElement::m_privateStoreState

privateinherited

Definition at line 137 of file IAuxElement.h.

supportsThinning

bool SG::AuxElement::supportsThinning = true

staticconstexprinherited

Mark that this type supports thinning operations.

See AthContainers/supportsThinning.h and AthenaPoolCnvSvc/T_AthenaPoolCnv.h. Helps guide which pool converter template will be used. If false, the default pool converter will be used rather than the aux store-specific one. Ordinary xAOD type should not touch this, but may be overridden in a derived class to handle certain special cases.

Definition at line 959 of file AuxElement.h.

---

The documentation for this class was generated from the following files:

• MissingETAssociation_v1.h
• MissingETAssociation_v1.cxx