#include <MissingETComponentMap_v1.h>

Inheritance diagram for xAOD::MissingETComponentMap_v1:

Collaboration diagram for xAOD::MissingETComponentMap_v1:

Public Types
typedef typename DataVectorBase< MissingETComponent_v1 >::Base	DataVector_BASE

typedef typename DataVectorBase< MissingETComponent_v1 >::Base	DVL_BASE

typedef BASE::PtrVector	PtrVector
	This is the type of the underlying `std::vector` (what `stdcont` returns). More...

typedef BASE::PtrVector	BaseContainer

typedef MissingETComponent_v1 *&	reference

typedef MissingETComponent_v1 *const &	const_reference

typedef BASE::size_type	size_type

typedef BASE::difference_type	difference_type

typedef MissingETComponent_v1 *	value_type

typedef BASE::allocator_type	allocator_type

typedef MissingETComponent_v1 **	pointer

typedef MissingETComponent_v1 const	const_pointer

typedef const MissingETComponent_v1 *	const_value_type

typedef MissingETComponent_v1	base_value_type
	The `T` value used as the template parameter. More...

typedef std::unique_ptr< base_value_type >	unique_type
	Type of a unique_ptr that can be used to insert elements into this container. More...

typedef DataModel_detail::ElementProxy< DataVector >	ElementProxy
	This type is used to proxy lvalue accesses to `DataVector` elements, in order to handle ownership. More...

typedef DataModel_detail::const_iterator< DataVector >	const_iterator
	Standard `const_iterator`. More...

typedef DataModel_detail::iterator< DataVector >	iterator
	Standard `iterator`. More...

typedef std::reverse_iterator< const_iterator >	const_reverse_iterator
	Standard `const_reverse_iterator`. More...

typedef std::reverse_iterator< iterator >	reverse_iterator
	Standard `reverse_iterator`. More...

typedef DataVector	base_data_vector

using	Deleter = typename BASE::Deleter

Public Member Functions
	MissingETComponentMap_v1 (SG::OwnershipPolicy own=SG::OWN_ELEMENTS, SG::IndexTrackingPolicy trackIndices=SG::DEFAULT_TRACK_INDICES)
	Default constructor. More...

	MissingETComponentMap_v1 (const MissingETComponentMap_v1::iterator &first, const MissingETComponentMap_v1::iterator &last, SG::OwnershipPolicy own=SG::OWN_ELEMENTS, SG::IndexTrackingPolicy trackIndices=SG::DEFAULT_TRACK_INDICES)
	Constructor from iterators. More...

virtual	~MissingETComponentMap_v1 ()
	Base class destructor. More...

void	resize (size_type sz)

void	pop_back ()

void	clear ()

void	sort ()

template<class COMPARE >
void	sort (COMPARE comp)

void	clear (SG::OwnershipPolicy ownPolicy)

void	clear (SG::OwnershipPolicy ownPolicy, SG::IndexTrackingPolicy trackIndices)

iterator	erase (iterator position)

iterator	erase (iterator first, iterator last)

Element access.
Change the vector capacity to match the current size. Note: this does not affect auxiliary data.
const MissingETComponent_v1 *	operator[] (size_type n) const
	Access an element, as an rvalue. More...

ElementProxy	operator[] (size_type n)
	Access an element, as an lvalue. More...

const MissingETComponent_v1 *	get (size_type n) const
	Access an element, as an rvalue. More...

const MissingETComponent_v1 *	at (size_type n) const
	Access an element, as an rvalue. More...

ElementProxy	at (size_type n)
	Access an element, as an lvalue. More...

const MissingETComponent_v1 *	front () const
	Access the first element in the collection as an rvalue. More...

ElementProxy	front ()
	Access the first element in the collection as an lvalue. More...

const MissingETComponent_v1 *	back () const
	Access the last element in the collection as an rvalue. More...

ElementProxy	back ()
	Access the last element in the collection as an lvalue. More...

Iterator creation.
const_iterator	begin () const noexcept
	Return a `const_iterator` pointing at the beginning of the collection. More...

iterator	begin () noexcept
	Return an `iterator` pointing at the beginning of the collection. More...

const_iterator	end () const noexcept
	Return a `const_iterator` pointing past the end of the collection. More...

iterator	end () noexcept
	Return an `iterator` pointing past the end of the collection. More...

const_reverse_iterator	rbegin () const noexcept
	Return a `const_reverse_iterator` pointing past the end of the collection. More...

reverse_iterator	rbegin () noexcept
	Return a `reverse_iterator` pointing past the end of the collection. More...

const_reverse_iterator	rend () const noexcept
	Return a `const_reverse_iterator` pointing at the beginning of the collection. More...

reverse_iterator	rend () noexcept
	Return a `reverse_iterator` pointing at the beginning of the collection. More...

const_iterator	cbegin () const noexcept
	Return a `const_iterator` pointing at the beginning of the collection. More...

const_iterator	cend () const noexcept
	Return a `const_iterator` pointing past the end of the collection. More...

const_reverse_iterator	crbegin () const noexcept
	Return a `const_reverse_iterator` pointing past the end of the collection. More...

const_reverse_iterator	crend () const noexcept
	Return a `const_reverse_iterator` pointing at the beginning of the collection. More...

Insertion operations.
value_type	push_back (value_type pElem)
	Add an element to the end of the collection. More...

value_type	push_back (std::unique_ptr< base_value_type > pElem)
	Add an element to the end of the collection. More...

value_type	emplace_back (value_type pElem)
	Add an element to the end of the collection. More...

iterator	insert (iterator position, value_type pElem)
	Add a new element to the collection. More...

iterator	insert (iterator position, std::unique_ptr< base_value_type > pElem)
	Add a new element to the collection. More...

void	insert (iterator position, InputIterator first, InputIterator last)
	Add a group of new elements to the collection. More...

void	insert (iterator position, InputIterator first, InputIterator last)
	Add a group of new elements to the collection. More...

void	insert (iterator position, std::initializer_list< value_type > l)
	Add a group of new elements to the collection. More...

iterator	emplace (iterator position, value_type pElem)
	Add a new element to the collection. More...

void	insertMove (iterator position, DataVector &other)
	Insert the contents of another `DataVector`, with auxiliary data copied via move semantics. More...

Find methods
const_iterator	find (const MissingET *pMET) const
	Find MET object referenced by pointer. More...

const_iterator	find (const std::string &name) const
	Find MET object referenced by name. More...

const_iterator	find (MissingETBase::Types::bitmask_t src) const
	Find MET object referenced by source indicator. More...

iterator	find (const MissingET *pMET)
	Find MET object referenced by pointer. More...

iterator	find (const std::string &name)
	Find MET object referenced by name. More...

iterator	find (MissingETBase::Types::bitmask_t src)
	Find MET object referenced by source indicator. More...

size_t	findIndex (const MissingET *pMET) const

size_t	findIndex (const std::string &name) const

size_t	findIndex (MissingETBase::Types::bitmask_t src) const

const MissingET *	retrieveMissingET (const std::string &name) const
	Retrieve MissingET object by name. More...

const MissingET *	retrieveMissingET (MissingETBase::Types::bitmask_t src, bool excl=false) const
	Retrieve MissingET object by source indicator. More...

const MissingET *	retrieveMissingET (MissingETBase::Types::bitmask_t src, MissingETBase::Types::bitmask_t sw, bool excl=false) const
	Retrieve MissingET object by source indicator and status word. More...

Client interactions with local cache
bool	checkUsage (const IParticle *pPart, MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster) const
	Check if a given object is already used in MET. More...

bool	checkUsage (MissingETBase::Types::object_vector_t &sig, MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster) const
	Check a list of objects for prior usage in MET reconstruction. More...

bool	addObjects (const MissingET pMET, const IParticle pPart, const MissingETBase::Types::object_vector_t &signalList, MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster)

bool	setClusters (const MissingET pMET, const IParticle pPart, const MissingETBase::Types::object_vector_t &signalList)

bool	setTracks (const MissingET pMET, const IParticle pPart, const MissingETBase::Types::object_vector_t &signalList)

bool	setObjects (const MissingET pMET, const IParticle pPart, const MissingETBase::Types::object_vector_t &objectList)

size_t	getComponentIndex (const IParticle *pPart) const

size_t	getObjectIndex (const IParticle *pPart) const

Constructors, destructors, assignment.
void	assign (InputIterator first, InputIterator last)
	Assign from iterators. More...

void	assign (std::initializer_list< value_type > l)

Size and capacity.
size_type	size () const noexcept
	Returns the number of elements in the collection. More...

void	reserve (size_type n)
	Attempt to preallocate enough memory for a specified number of elements. More...

Element access.
Change the vector capacity to match the current size. Note: this does not affect auxiliary data.
const MissingETComponent_v1 *	operator[] (size_type n) const
	Access an element, as an rvalue. More...

ElementProxy	operator[] (size_type n)
	Access an element, as an lvalue. More...

const MissingETComponent_v1 *	get (size_type n) const
	Access an element, as an rvalue. More...

const MissingETComponent_v1 *	at (size_type n) const
	Access an element, as an rvalue. More...

ElementProxy	at (size_type n)
	Access an element, as an lvalue. More...

const MissingETComponent_v1 *	front () const
	Access the first element in the collection as an rvalue. More...

ElementProxy	front ()
	Access the first element in the collection as an lvalue. More...

const MissingETComponent_v1 *	back () const
	Access the last element in the collection as an rvalue. More...

ElementProxy	back ()
	Access the last element in the collection as an lvalue. More...

Iterator creation.
const_iterator	begin () const noexcept
	Return a `const_iterator` pointing at the beginning of the collection. More...

iterator	begin () noexcept
	Return an `iterator` pointing at the beginning of the collection. More...

const_iterator	end () const noexcept
	Return a `const_iterator` pointing past the end of the collection. More...

iterator	end () noexcept
	Return an `iterator` pointing past the end of the collection. More...

const_reverse_iterator	rbegin () const noexcept
	Return a `const_reverse_iterator` pointing past the end of the collection. More...

reverse_iterator	rbegin () noexcept
	Return a `reverse_iterator` pointing past the end of the collection. More...

const_reverse_iterator	rend () const noexcept
	Return a `const_reverse_iterator` pointing at the beginning of the collection. More...

reverse_iterator	rend () noexcept
	Return a `reverse_iterator` pointing at the beginning of the collection. More...

const_iterator	cbegin () const noexcept
	Return a `const_iterator` pointing at the beginning of the collection. More...

const_iterator	cend () const noexcept
	Return a `const_iterator` pointing past the end of the collection. More...

const_reverse_iterator	crbegin () const noexcept
	Return a `const_reverse_iterator` pointing past the end of the collection. More...

const_reverse_iterator	crend () const noexcept
	Return a `const_reverse_iterator` pointing at the beginning of the collection. More...

Insertion operations.
value_type	push_back (value_type pElem)
	Add an element to the end of the collection. More...

value_type	push_back (std::unique_ptr< base_value_type > pElem)
	Add an element to the end of the collection. More...

value_type	emplace_back (value_type pElem)
	Add an element to the end of the collection. More...

iterator	insert (iterator position, value_type pElem)
	Add a new element to the collection. More...

iterator	insert (iterator position, std::unique_ptr< base_value_type > pElem)
	Add a new element to the collection. More...

void	insert (iterator position, InputIterator first, InputIterator last)
	Add a group of new elements to the collection. More...

void	insert (iterator position, InputIterator first, InputIterator last)
	Add a group of new elements to the collection. More...

void	insert (iterator position, std::initializer_list< value_type > l)
	Add a group of new elements to the collection. More...

iterator	emplace (iterator position, value_type pElem)
	Add a new element to the collection. More...

void	insertMove (iterator position, DataVector &other)
	Insert the contents of another `DataVector`, with auxiliary data copied via move semantics. More...

Static Public Attributes
static const bool	has_virtual
	This is true for any `DataVector` class if we need to use virtual derivation to get to the base `DataVector` class. More...

static constexpr bool	must_own
	If true, then this type must own its contents. More...

Protected Types
Internal types for local cache handling
typedef size_t	signal_key_t
	Key type for signals (clusters, tracks) is type of index in container. More...

typedef const IParticle *	particle_key_t
	Key type for physics objects is the base pointer type of these objects. More...

typedef MissingETBase::Types::indexedlink_t	indexedlink_t
	Type for the description of the link locations. More...

typedef std::vector< indexedlink_t >	signal_vector_t
	Indexed list type for signal object link locations. More...

typedef std::map< particle_key_t, indexedlink_t >	particle_map_t
	Map type for physics object. More...

Protected Member Functions
Internal functions for local cache handling

template<int N>
size_t	f_getIndex (const IParticle *pPart) const

Protected Attributes
Internal data for local cache
signal_vector_t	m_clusterLinks
	Store for linked cluuster signal information lookup. More...

signal_vector_t	m_trackLinks
	Store for linked track signal information lookup. More...

particle_map_t	m_particleLinks
	Store for linked physics object information lookup. More...

Swap and sort.
void	swap (DataVector &rhs)
	Swap this collection with another. More...

static void	iter_swap (iterator a, iterator b)
	Swap the referents of two `DataVector` iterators. More...

Non-standard operations.
void	clear (std::unique_ptr< Deleter > deleter)
	Erase all the elements in the collection, and change how elements are to be deleted. More...

void	swapElement (size_type index, value_type newElem, reference oldElem)
	Swap one element out of the container. More...

void	swapElement (iterator pos, value_type newElem, reference oldElem)
	Swap one element out of the container. More...

void	swapElement (size_type index, std::unique_ptr< base_value_type > newElem, std::unique_ptr< base_value_type > &oldElem)
	Swap one element out of the container. More...

void	swapElement (iterator pos, std::unique_ptr< base_value_type > newElem, std::unique_ptr< base_value_type > &oldElem)
	Swap one element out of the container. More...

virtual const DataModel_detail::DVLInfoBase &	dvlinfo_v () const
	Return the DV/DL info struct for this class. More...

const SG::AuxVectorBase &	auxbase () const
	Convert to `AuxVectorBase`. More...

size_type	max_size () const noexcept
	Returns the `size()` of the largest possible collection. More...

size_type	capacity () const noexcept
	Returns the total number of elements that the collection can hold before needing to allocate more memory. More...

bool	empty () const noexcept
	Returns `true` if the collection is empty. More...

void	shrink_to_fit ()

const PtrVector &	stdcont () const
	Return the underlying `std::vector` of the container. More...

SG::OwnershipPolicy	ownPolicy () const
	Return the ownership policy setting for this container. More...

static const DataModel_detail::DVLInfoBase &	dvlinfo ()
	Return the DV/DL info struct for this class. More...

static int	baseOffset (const std::type_info &ti)
	Return the offset of a base `DataVector` class. More...

Internal operations.
void	resortAux (iterator beg, iterator end)
	Reset indices / reorder aux data after elements have been permuted. More...

void	testInsert (const char *op)
	Test if we can insert; raise an exception if not. More...

void	testInsertOol (const char *op)
	Test if we can insert; raise an exception if not. More...

void	clearMostDerived ()
	Clear `m_isMostDerived` for this instance and for all bases. More...

virtual void	setMostDerived ()
	Set `m_isMostDerived` for this instance and clear it for all bases. More...

typedef ROOT::Meta::Selection::DataVector< MissingETComponent_v1, DataVector_BASE >::self	self

SG::IsMostDerivedFlag	m_isMostDerived
	This flag is true if this DV instance is the most-derived one. More...

static int	baseOffset1 (const char *p, const DataVector &dv, const std::type_info &ti)
	Helper for `baseOffset`. More...

static const MissingETComponent_v1 *	do_cast (const typename PtrVector::value_type p)
	Helper to shorten calls to `DataModel_detail::DVLCast`. More...

static MissingETComponent_v1 *	do_cast_nc (typename PtrVector::value_type p)
	Helper to shorten calls to `DataModel_detail::DVLCast`. More...

void	assignElement (typename BaseContainer::iterator pos, value_type newElem)
	Handle element assignment. More...

void	assignElement (typename BaseContainer::iterator pos, std::unique_ptr< base_value_type > newElem)
	Handle element assignment. More...

void	assignBaseElement (typename BaseContainer::iterator pos, typename BaseContainer::value_type newElem)
	Handle element assignment from a base pointer. More...

void	shift (size_t pos, ptrdiff_t offs)
	Shift the auxiliary elements of the container. More...

virtual const std::type_info &	dv_typeid () const
	Find the most-derived `DataVector` class in the hierarchy. More...

Internal object lookup cache handlers
static const size_t	m_clusterLinkReserve =10000

static const size_t	m_trackLinkReserve =10000

bool	f_checkObjectUsage (MissingETBase::Types::object_vector_t &sig, const signal_vector_t &signalLinks) const
	Check signal object usage. More...

bool	f_checkObjectUsage (MissingETBase::Types::object_vector_t &objects, const particle_map_t &physicsLinks) const
	Check physics object usage. More...

void	f_fillLookupCache ()
	Fill the lookup cache from the composition map data content. More...

void	f_clearLookupCache ()
	Clear the lookup cache. More...

void	f_setupLookupCache (signal_vector_t &signalLinks, size_t reserve)
	Set up the signal object lookup. More...

template<int OBJTYPE>
bool	f_extractSignal (MissingETBase::Types::object_vector_t &sig) const
	Signal type extractor. More...

const MissingET *	f_retrieveMissingETExcl (MissingETBase::Types::bitmask_t src) const

const MissingET *	f_retrieveMissingETExcl (MissingETBase::Types::bitmask_t src, MissingETBase::Types::bitmask_t sw) const

const MissingET *	f_retrieveMissingETIncl (MissingETBase::Types::bitmask_t src) const

const MissingET *	f_retrieveMissingETIncl (MissingETBase::Types::bitmask_t src, MissingETBase::Types::bitmask_t sw) const

Detailed Description

Definition at line 24 of file MissingETComponentMap_v1.h.

Member Typedef Documentation

◆ allocator_type

typedef BASE::allocator_type DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::allocator_type

inherited

Definition at line 816 of file DataVector.h.

◆ base_data_vector

typedef DataVector DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::base_data_vector

inherited

Definition at line 853 of file DataVector.h.

◆ base_value_type

typedef MissingETComponent_v1 DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::base_value_type

inherited

The T value used as the template parameter.

Note that this is different from value_type (that's T*).

Definition at line 824 of file DataVector.h.

◆ BaseContainer

typedef BASE::PtrVector DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::BaseContainer

inherited

Definition at line 806 of file DataVector.h.

◆ const_iterator

typedef DataModel_detail::const_iterator<DataVector> DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::const_iterator

inherited

Standard const_iterator.

Definition at line 837 of file DataVector.h.

◆ const_pointer

typedef MissingETComponent_v1 * const* DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::const_pointer

inherited

Definition at line 818 of file DataVector.h.

◆ const_reference

typedef MissingETComponent_v1 * const& DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::const_reference

inherited

Definition at line 812 of file DataVector.h.

◆ const_reverse_iterator

typedef std::reverse_iterator<const_iterator> DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::const_reverse_iterator

inherited

Standard const_reverse_iterator.

Definition at line 846 of file DataVector.h.

◆ const_value_type

typedef const MissingETComponent_v1 * DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::const_value_type

inherited

Definition at line 820 of file DataVector.h.

◆ DataVector_BASE

typedef typename DataVectorBase<MissingETComponent_v1 >::Base DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::DataVector_BASE

inherited

Definition at line 796 of file DataVector.h.

◆ Deleter

using DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::Deleter = typename BASE::Deleter

inherited

Definition at line 856 of file DataVector.h.

◆ difference_type

typedef BASE::difference_type DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::difference_type

inherited

Definition at line 814 of file DataVector.h.

◆ DVL_BASE

typedef typename DataVectorBase<MissingETComponent_v1 >::Base DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::DVL_BASE

inherited

Definition at line 797 of file DataVector.h.

◆ ElementProxy

typedef DataModel_detail::ElementProxy<DataVector> DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::ElementProxy

inherited

This type is used to proxy lvalue accesses to DataVector elements, in order to handle ownership.

Definition at line 832 of file DataVector.h.

◆ indexedlink_t

typedef MissingETBase::Types::indexedlink_t xAOD::MissingETComponentMap_v1::indexedlink_t

protected

Type for the description of the link locations.

This is a two-component type which allows holding the index of the xAOD::MissingETComponent_v1 object a physics or signal object is linked from, and the index of this linked object in the contributing object list.

Definition at line 190 of file MissingETComponentMap_v1.h.

◆ iterator

typedef DataModel_detail::iterator<DataVector> DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::iterator

inherited

Standard iterator.

Note that lvalue references here will yield an ElementProxy, not a reference.

Definition at line 841 of file DataVector.h.

◆ particle_key_t

typedef const IParticle* xAOD::MissingETComponentMap_v1::particle_key_t

protected

Key type for physics objects is the base pointer type of these objects.

Definition at line 189 of file MissingETComponentMap_v1.h.

◆ particle_map_t

typedef std::map<particle_key_t,indexedlink_t> xAOD::MissingETComponentMap_v1::particle_map_t

protected

Map type for physics object.

In case of physics objects, a map look-up is implemented as the lack of a common container for these objects does not allow using the index as a unique key. The object pointer is used instead, and the look-up is provided by a standard map (binary search). Typically, the number of entries in this map is rather small (much less than 100) so that this storage technology should not introduce performance problems.

Definition at line 201 of file MissingETComponentMap_v1.h.

◆ pointer

typedef MissingETComponent_v1 ** DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::pointer

inherited

Definition at line 817 of file DataVector.h.

◆ PtrVector

typedef BASE::PtrVector DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::PtrVector

inherited

This is the type of the underlying std::vector (what stdcont returns).

Definition at line 805 of file DataVector.h.

◆ reference

typedef MissingETComponent_v1 *& DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::reference

inherited

Definition at line 811 of file DataVector.h.

◆ reverse_iterator

typedef std::reverse_iterator<iterator> DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::reverse_iterator

inherited

Standard reverse_iterator.

Note that lvalue references here will yield an ElementProxy, not a reference.

Definition at line 851 of file DataVector.h.

◆ self

typedef ROOT::Meta::Selection::DataVector<MissingETComponent_v1 , DataVector_BASE>::self DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::self

privateinherited

Definition at line 2042 of file DataVector.h.

◆ signal_key_t

typedef size_t xAOD::MissingETComponentMap_v1::signal_key_t

protected

Key type for signals (clusters, tracks) is type of index in container.

Definition at line 188 of file MissingETComponentMap_v1.h.

◆ signal_vector_t

typedef std::vector<indexedlink_t> xAOD::MissingETComponentMap_v1::signal_vector_t

protected

Indexed list type for signal object link locations.

In case of a signal (xAOD::CaloCluster, xAOD::TrackParticle) object look-up, the index of these objects can be directly used to check if they have already been used in the actual MET composition (random access in this index parallel store - with respect to the actual xAOD::CaloClusterContainer and the xAOD::TrackParticleContainer).

Definition at line 195 of file MissingETComponentMap_v1.h.

◆ size_type

typedef BASE::size_type DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::size_type

inherited

Definition at line 813 of file DataVector.h.

◆ unique_type

typedef std::unique_ptr<base_value_type> DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::unique_type

inherited

Type of a unique_ptr that can be used to insert elements into this container.

Definition at line 828 of file DataVector.h.

◆ value_type

typedef MissingETComponent_v1 * DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::value_type

inherited

Definition at line 815 of file DataVector.h.

Constructor & Destructor Documentation

◆ MissingETComponentMap_v1() [1/2]

MissingETComponentMap_v1::MissingETComponentMap_v1	(	SG::OwnershipPolicy	own = `SG::OWN_ELEMENTS`,
		SG::IndexTrackingPolicy	trackIndices = `SG::DEFAULT_TRACK_INDICES`
	)

Default constructor.

Definition at line 25 of file MissingETComponentMap_v1.cxx.

   : DataVector<MissingETComponent_v1>(own,trackIndices)
 {
   this->f_setupLookupCache(m_clusterLinks,m_clusterLinkReserve); 
   this->f_setupLookupCache(m_trackLinks,m_trackLinkReserve); 
 }

◆ MissingETComponentMap_v1() [2/2]

MissingETComponentMap_v1::MissingETComponentMap_v1	(	const MissingETComponentMap_v1::iterator &	first,
		const MissingETComponentMap_v1::iterator &	last,
		SG::OwnershipPolicy	own = `SG::OWN_ELEMENTS`,
		SG::IndexTrackingPolicy	trackIndices = `SG::DEFAULT_TRACK_INDICES`
	)

Constructor from iterators.

Definition at line 32 of file MissingETComponentMap_v1.cxx.

   : DataVector<MissingETComponent_v1>(first,last,own,trackIndices)
 {
   this->f_setupLookupCache(m_clusterLinks,m_clusterLinkReserve); 
   this->f_setupLookupCache(m_trackLinks,m_trackLinkReserve); 
 }

◆ ~MissingETComponentMap_v1()

MissingETComponentMap_v1::~MissingETComponentMap_v1 ( )

virtual

Base class destructor.

Definition at line 41 of file MissingETComponentMap_v1.cxx.

42 { this->clearCache(); }

Member Function Documentation

◆ addObjects()

bool MissingETComponentMap_v1::addObjects	(	const MissingET *	pMET,
		const IParticle *	pPart,
		const MissingETBase::Types::object_vector_t &	signalList,
		MissingETBase::UsageHandler::Policy	p = `MissingETBase::UsageHandler::OnlyCluster`
	)

Definition at line 257 of file MissingETComponentMap_v1.cxx.

 {
   bool flag(false);
   switch ( p )
     {
     case MissingETBase::UsageHandler::OnlyCluster:
       { flag = this->setClusters(pMET,pPart,signalList); break; }
     case MissingETBase::UsageHandler::OnlyTrack:
       { flag = this->setTracks(pMET,pPart,signalList); break; }
     case MissingETBase::UsageHandler::TrackCluster:
       { bool cFlg(this->setClusters(pMET,pPart,signalList)); bool tFlg(this->setTracks(pMET,pPart,signalList)); flag = cFlg || tFlg; break; } 
     case MissingETBase::UsageHandler::PhysicsObject:
       { flag = this->setObjects(pMET,pPart,signalList); break; }
     default:
       { break; }
     }
   return flag;
 }

◆ assign() [1/2]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::assign	(	InputIterator	first,
		InputIterator	last
	)

inherited

Assign from iterators.

Parameters

first	The start of the range to put in the container.
last	The end of the range to put in the container.

Any existing owned elements will be released. The DataVector's ownership policy determines whether it will take ownership of the new elements.

◆ assign() [2/2]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::assign ( std::initializer_list< value_type > l )

inherited

Parameters

l	An initializer list.

Any existing owned elements will be released. The DataVector's ownership policy determines whether it will take ownership of the new elements.

◆ assignBaseElement()

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::assignBaseElement	(	typename BaseContainer::iterator	pos,
		typename BaseContainer::value_type	newElem
	)

privateinherited

Handle element assignment from a base pointer.

Parameters

pos	Position in the container to assign.
newElem	The new element to assign.

The old element is freed if this container owns elements. Auxiliary data are copied if appropriate.

◆ assignElement() [1/2]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::assignElement	(	typename BaseContainer::iterator	pos,
		std::unique_ptr< base_value_type >	newElem
	)

privateinherited

Handle element assignment.

Parameters

pos	Position in the container to assign.
newElem	The new element to assign.

The container must own its elements. Auxiliary data are copied if appropriate.

◆ assignElement() [2/2]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::assignElement	(	typename BaseContainer::iterator	pos,
		value_type	newElem
	)

privateinherited

Handle element assignment.

Parameters

pos	Position in the container to assign.
newElem	The new element to assign.

The old element is freed if this container owns elements. Auxiliary data are copied if appropriate.

◆ at() [1/2]

ElementProxy DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::at ( size_type n )

inherited

Access an element, as an lvalue.

Parameters

n	Array index to access.

Returns: Proxy to the element at n.

Will raise std::out_of_range if the index is out-of-bounds. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ at() [2/2]

const MissingETComponent_v1 * DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::at ( size_type n ) const

inherited

Access an element, as an rvalue.

Parameters

n	Array index to access.

Returns: The element at n.

Will raise std::out_of_range if the index is out-of-bounds. Note that we return a const T* rather than a reference.

◆ auxbase()

const SG::AuxVectorBase& DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::auxbase

inherited

Convert to AuxVectorBase.

Needed to get AuxVectorBase from a ConstDataVector. Present in DataVector as well for consistency. We only really need it in the base class; however, root6 fails constructing a TMethodCall for this if there is virtual derivation. A workaround is to redeclare this in the derived classes too.

◆ back() [1/2]

ElementProxy DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::back

inherited

Access the last element in the collection as an lvalue.

Returns: Proxy to the last element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ back() [2/2]

const MissingETComponent_v1 * DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::back

inherited

Access the last element in the collection as an rvalue.

Returns: The last element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a const T* rather than a reference.

◆ baseOffset()

static int DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::baseOffset ( const std::type_info & ti )

staticinherited

Return the offset of a base DataVector class.

Parameters

ti	`std::type_info` of the desired class.

If ti represents a DataVector base class of this one, then return the offset of that base class. Otherwise, return -1.

This function is here due to limitations of root 6, which can't calculate these offsets correctly from the dictionary if virtual derivation is used.

◆ baseOffset1()

static int DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::baseOffset1	(	const char *	p,
		const DataVector< MissingETComponent_v1 > &	dv,
		const std::type_info &	ti
	)

staticinherited

Helper for baseOffset.

Parameters

p	Pointer to the start of the top-level object.
dv	Reference to the DataVector object.
ti	`std::type_info` of the desired class.

If ti represents a DataVector base class of this one, then return the offset of that base class. Otherwise, return -1.

◆ begin() [1/2]

const_iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::begin

noexceptinherited

Return a const_iterator pointing at the beginning of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ begin() [2/2]

iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::begin

noexceptinherited

Return an iterator pointing at the beginning of the collection.

Returns: An iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ capacity()

size_type DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::capacity

noexceptinherited

Returns the total number of elements that the collection can hold before needing to allocate more memory.

◆ cbegin()

const_iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::cbegin

noexceptinherited

Return a const_iterator pointing at the beginning of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ cend()

const_iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::cend

noexceptinherited

Return a const_iterator pointing past the end of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ checkUsage() [1/2]

bool MissingETComponentMap_v1::checkUsage	(	const IParticle *	pPart,
		MissingETBase::UsageHandler::Policy	p = `MissingETBase::UsageHandler::OnlyCluster`
	)		const

Check if a given object is already used in MET.

Returns: true if the referenced signal object is already used.

Parameters

[in]	pPart	generic (base class) pointer to signal object (xAOD::CaloCluster or xAOD::TrackParticle).
[in]	p	tags signal type to be checked to usage (optional, default is MissingETBase::UsageHandler::OnlyCluster).

Definition at line 187 of file MissingETComponentMap_v1.cxx.

188 { MissingETBase::Types::object_vector_t objects; objects.push_back(pPart); return this->checkUsage(objects,p); }

◆ checkUsage() [2/2]

bool MissingETComponentMap_v1::checkUsage	(	MissingETBase::Types::object_vector_t &	sig,
		MissingETBase::UsageHandler::Policy	p = `MissingETBase::UsageHandler::OnlyCluster`
	)		const

Check a list of objects for prior usage in MET reconstruction.

Returns: true if any of the objects in the list has already been used in another MET contribution. The iput object list contains pointer references to objects which have not yet been used.

Parameters

[in,out]	sig	reference to modifiable list of objects.
[in]	p	tags signal type to be checked to usage (optional, default is MissingETBase::UsageHandler::OnlyCluster).

Note: The list of signals on input can contain various signal (object) types. The modified list contains only references to objects with types determined by the MissingETBase::UsageHandler::Policy. By default, those are clusters.; Usage is always measured with respect to the type given by MissingETBase::UsageHandler::Policy. For example, if the input signal list has mixed object types, its content on return contains only references to objects of the type determined by the MissingETBase::UsageHandler::Policy. By default, those are clusters. This modification of the input list does not indicate that any clusters in this list have already been used. This is done by the return value.

Definition at line 190 of file MissingETComponentMap_v1.cxx.

 {
   bool retVal(false);
   switch ( p )
     {
     case MissingETBase::UsageHandler::OnlyCluster:
       { if ( f_extractSignal<xAOD::Type::CaloCluster>(signals) ) { retVal = this->f_checkObjectUsage(signals,m_clusterLinks); } break; }
     case MissingETBase::UsageHandler::OnlyTrack:
       { if ( f_extractSignal<xAOD::Type::TrackParticle>(signals) ) { retVal = this->f_checkObjectUsage(signals,m_trackLinks); } break; }
     case MissingETBase::UsageHandler::TrackCluster:
       {
     MissingETBase::Types::object_vector_t ins(signals.begin(),signals.end());
     size_t nSig(0);
     if ( f_extractSignal<xAOD::Type::CaloCluster>(signals) )
       { nSig = signals.size(); this->f_checkObjectUsage(signals,m_clusterLinks); }
     if ( f_extractSignal<xAOD::Type::TrackParticle>(ins) )
       { nSig += ins.size(); this->f_checkObjectUsage(ins,m_trackLinks); }
     signals.insert(signals.end(),ins.begin(),ins.end());
     retVal = signals.size() == nSig;
     break;
       }
     case MissingETBase::UsageHandler::PhysicsObject:
       { retVal = this->f_checkObjectUsage(signals,m_particleLinks); break; }
     default:
       { break; }
     } // switch 
   return retVal;
 }

◆ clear() [1/4]

void xAOD::MissingETComponentMap_v1::clear ( )

◆ clear() [2/4]

void xAOD::MissingETComponentMap_v1::clear ( SG::OwnershipPolicy ownPolicy )

◆ clear() [3/4]

void xAOD::MissingETComponentMap_v1::clear	(	SG::OwnershipPolicy	ownPolicy,
		SG::IndexTrackingPolicy	trackIndices
	)

◆ clear() [4/4]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::clear ( std::unique_ptr< Deleter > deleter )

inherited

Erase all the elements in the collection, and change how elements are to be deleted.

Parameters

deleter Object to be used to delete object. Passing nullptr will change back to the default.

If the container owns its elements, then the removed elements will be deleted. Any duplicates will be removed in this process, but don't rely on this. After the current elements are deleted, the Deleter object is changed.

◆ clearMostDerived()

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::clearMostDerived

protectedinherited

Clear m_isMostDerived for this instance and for all bases.

Called from the constructor after setting m_isMostDerived.

◆ crbegin()

const_reverse_iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::crbegin

noexceptinherited

Return a const_reverse_iterator pointing past the end of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ crend()

const_reverse_iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::crend

noexceptinherited

Return a const_reverse_iterator pointing at the beginning of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ do_cast()

static const MissingETComponent_v1 * DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::do_cast ( const typename PtrVector::value_type p )

staticinherited

Helper to shorten calls to DataModel_detail::DVLCast.

Parameters

p	The value to convert.

Returns: The value as a const T*.

The conversion will be done with static_cast if possible, with dynamic_cast otherwise.

◆ do_cast_nc()

static MissingETComponent_v1 * DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::do_cast_nc ( typename PtrVector::value_type p )

staticinherited

Helper to shorten calls to DataModel_detail::DVLCast.

Parameters

p	The value to convert.

Returns: The value as a T*.

The conversion will be done with static_cast if possible, with dynamic_cast otherwise.

◆ dv_typeid()

virtual const std::type_info& DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::dv_typeid

privatevirtualinherited

Find the most-derived DataVector class in the hierarchy.

Returns: The type_info for the class for which this method gets run.

This is used to generate a nice error message when the most-derived check for insertions fails. Every DataVector defines this virtual method, so when it's called, the one corresponding to the most-derived DataVector gets run.

◆ dvlinfo()

static const DataModel_detail::DVLInfoBase& DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::dvlinfo

staticinherited

Return the DV/DL info struct for this class.

This can be used to make sure that it's instantiated.

◆ dvlinfo_v()

virtual const DataModel_detail::DVLInfoBase& DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::dvlinfo_v

virtualinherited

Return the DV/DL info struct for this class.

This can be used to make sure that it's instantiated.

◆ emplace()

iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::emplace	(	iterator	position,
		value_type	pElem
	)

inherited

Add a new element to the collection.

Parameters

position	Iterator before which the element will be added.
pElem	The element to add to the collection.

Returns: An iterator that points to the inserted data.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

For DataVector, this is just the same as insert. It's included just for interface compatibility with std::vector.

◆ emplace_back()

value_type DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::emplace_back ( value_type pElem )

inherited

Add an element to the end of the collection.

Parameters

pElem The element to add to the collection.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

For DataVector, this is like the same as push_back, and it returns the pushed element. It's included just for interface compatibility with std::vector.

◆ empty()

bool DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::empty

noexceptinherited

Returns true if the collection is empty.

◆ end() [1/2]

const_iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::end

noexceptinherited

Return a const_iterator pointing past the end of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ end() [2/2]

iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::end

noexceptinherited

Return an iterator pointing past the end of the collection.

Returns: An iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ erase() [1/2]

iterator xAOD::MissingETComponentMap_v1::erase	(	iterator	first,
		iterator	last
	)

◆ erase() [2/2]

iterator xAOD::MissingETComponentMap_v1::erase ( iterator position )

◆ f_checkObjectUsage() [1/2]

bool MissingETComponentMap_v1::f_checkObjectUsage	(	MissingETBase::Types::object_vector_t &	objects,
		const particle_map_t &	physicsLinks
	)		const

protected

Check physics object usage.

Returns: true if any of the physics objects in the input list is already marked as used. In addition, all used objects are removed from the input (physics) object list. If none of the objects in this list is already used, false is returned.

Parameters

[in,out]	objects	reference to modifiable list of physics objects to be checked for usage in MET reconstruction.
[in]	physicsLinks	reference to modifiable map of link descriptors for physics objects already used (means linked to a MET contribution).

Note: This method does not add yet unused physics objects to the signal link list, as this decision is controlled by the specific MET reconstruction tool.

Definition at line 242 of file MissingETComponentMap_v1.cxx.

 {
   if ( objects.empty() ) { return false; }
   //
   size_t oldSize(objects.size());
   MissingETBase::Types::object_vector_t::iterator fObj(objects.begin());
   while ( fObj != objects.end() )
     { if ( physicsLinks.find(*fObj) != physicsLinks.end() ) { fObj = objects.erase(fObj); } else { ++fObj; } }
   return objects.size() != oldSize;
 }

◆ f_checkObjectUsage() [2/2]

bool MissingETComponentMap_v1::f_checkObjectUsage	(	MissingETBase::Types::object_vector_t &	sig,
		const signal_vector_t &	signalLinks
	)		const

protected

Check signal object usage.

Returns: true if any of the signal objects in the inout list is already marked as used. In addition, all used objects are removed from the input (signal) object list. If none of the objects in this list is already used, false is returned.

Parameters

[in,out]	sig	reference to modifiable list of signal objects to be checked for usage in MET reconstruction.
[in]	signalLinks	reference to modifiable list of signals already used (means linked to a MET contribution).

Note: This method does not add yet unused signal objects to the signal link list, as this decision is controlled by the specific MET reconstruction tool.

Definition at line 219 of file MissingETComponentMap_v1.cxx.

 {
   if ( signals.empty() || signalLinks.empty() ) return false;
   // loop on signals
   size_t oldSize(signals.size());
   MissingETBase::Types::object_vector_t::iterator fSig(signals.begin());
   while ( fSig != signals.end() ) 
     {
       size_t fIdx((*fSig)->index()); 
       if( fIdx >= signalLinks.size() ) {
     // if invalid, something probably went wrong in reconstruction, so complain
     // this should raise an out-of-range exception
     printf("MissingETComponentMap::f_checkObjectUsage(...) - ERROR - searching for a signal with index (%zu) beyond signal container range (%zu).", fIdx, signalLinks.size());
     printf("MissingETComponentMap::f_checkObjectUsage(...) - ERROR - this may indicate an inconsistency in the signal containers.");    
       }
       // signal already used
       if ( signalLinks.at(fIdx) != MissingETBase::Numerical::invalidLink() ) { fSig = signals.erase(fSig); }
       // signal not yet used
       else { ++fSig; }
     } // loop on signals
   return oldSize != signals.size(); 
 }

◆ f_clearLookupCache()

void MissingETComponentMap_v1::f_clearLookupCache ( )

protected

Clear the lookup cache.

Definition at line 360 of file MissingETComponentMap_v1.cxx.

361 { m_clusterLinks.clear(); m_trackLinks.clear(); m_particleLinks.clear(); }

◆ f_extractSignal()

template<int OBJTYPE>

bool xAOD::MissingETComponentMap_v1::f_extractSignal ( MissingETBase::Types::object_vector_t & sig ) const

inlineprotected

Signal type extractor.

Returns: true if input object list contains requested signal type, else false. The input object list is filtered on return, meaning it only contains objects of the requested type. A return of false thus indicates an empty list.

Template Parameters

SIGNAL signal type of extracted objects.

Parameters

[in,out] sig reference to modifiable list of signal objects to be checked for usage in MET reconstruction.

Definition at line 279 of file MissingETComponentMap_v1.h.

     {
       MissingETBase::Types::object_vector_t::iterator fSign(sig.begin());
       while ( fSign != sig.end() ) { if ( (*fSign)->type() != OBJTYPE ) { fSign = sig.erase(fSign); } else { ++fSign; } }
       return !sig.empty(); 
     }

◆ f_fillLookupCache()

void MissingETComponentMap_v1::f_fillLookupCache ( )

protected

Fill the lookup cache from the composition map data content.

Definition at line 363 of file MissingETComponentMap_v1.cxx.

364 {

366 }

◆ f_getIndex()

template<int N>

size_t xAOD::MissingETComponentMap_v1::f_getIndex ( const IParticle * pPart ) const

inlineprotected

Definition at line 225 of file MissingETComponentMap_v1.h.

     {
       // check on cluster signal
       if ( pPart->type() == Type::CaloCluster ) 
     { size_t idx(pPart->index()); return idx < m_clusterLinks.size() ? std::get<N>( m_clusterLinks.at(idx)) : MissingETBase::Numerical::invalidIndex(); }
       // check on track signal
       if ( pPart->type() == Type::TrackParticle )
     { size_t idx(pPart->index()); return idx < m_trackLinks.size() ? std::get<N>(m_trackLinks.at(idx)) : MissingETBase::Numerical::invalidIndex(); }
       // 
       particle_map_t::const_iterator fPart(m_particleLinks.find(pPart));
       return fPart != m_particleLinks.end() ? std::get<N>(fPart->second) : MissingETBase::Numerical::invalidIndex();
     }

◆ f_retrieveMissingETExcl() [1/2]

const MissingET * MissingETComponentMap_v1::f_retrieveMissingETExcl ( MissingETBase::Types::bitmask_t src ) const

protected

Definition at line 146 of file MissingETComponentMap_v1.cxx.

 {
   const_iterator fCont(this->begin());
   const_iterator lCont(this->end());
   while ( fCont != lCont && (*fCont)->metObject()->source() != src ) { ++fCont; }
   if ( fCont != lCont ) return (*fCont)->metObject();
   return nullptr;
 }

◆ f_retrieveMissingETExcl() [2/2]

const MissingET * MissingETComponentMap_v1::f_retrieveMissingETExcl	(	MissingETBase::Types::bitmask_t	src,
		MissingETBase::Types::bitmask_t	sw
	)		const

protected

Definition at line 155 of file MissingETComponentMap_v1.cxx.

 { 
   const_iterator fCont(this->begin());
   const_iterator lCont(this->end());
   while ( fCont != lCont && ( (*fCont)->metObject()->source() != src || (*fCont)->statusWord() != sw ) ) { ++fCont; }
   if ( fCont != lCont ) return (*fCont)->metObject();
   return nullptr;
 }

◆ f_retrieveMissingETIncl() [1/2]

const MissingET * MissingETComponentMap_v1::f_retrieveMissingETIncl ( MissingETBase::Types::bitmask_t src ) const

protected

Definition at line 164 of file MissingETComponentMap_v1.cxx.

 { 
   const_iterator fCont(this->begin());
   const_iterator lCont(this->end());
   while ( fCont != lCont && !MissingETBase::Source::hasPattern((*fCont)->metObject()->source(),src) ) { ++fCont; }
   if ( fCont != lCont ) return (*fCont)->metObject();
   return nullptr;
 }

◆ f_retrieveMissingETIncl() [2/2]

const MissingET * MissingETComponentMap_v1::f_retrieveMissingETIncl	(	MissingETBase::Types::bitmask_t	src,
		MissingETBase::Types::bitmask_t	sw
	)		const

protected

Definition at line 173 of file MissingETComponentMap_v1.cxx.

 {
   const_iterator fCont(this->begin());
   const_iterator lCont(this->end());
   while ( fCont != lCont && ( !MissingETBase::Source::hasPattern((*fCont)->metObject()->source(),src) ||
                               !MissingETBase::Status::Tags::hasPattern((*fCont)->statusWord(),sw) ) ) { ++fCont; }
   if ( fCont != lCont ) return (*fCont)->metObject();
   return nullptr;
 }

◆ f_setupLookupCache()

void MissingETComponentMap_v1::f_setupLookupCache	(	signal_vector_t &	signalLinks,
		size_t	reserve
	)

protected

Set up the signal object lookup.

Definition at line 357 of file MissingETComponentMap_v1.cxx.

358 { signalLinks.clear(); if ( reserve > 0 ) { signalLinks.reserve(reserve); } }

◆ find() [1/6]

MissingETComponentMap_v1::iterator MissingETComponentMap_v1::find ( const MissingET * pMET )

Find MET object referenced by pointer.

Returns: Iterator referencing a modifiable xAOD::MissingETComponent_v1 object linking to the given MET object. If the MET object is not in the ccomposition map, an end iterator is returned.

Parameters

[in] pMET pointer to the xAOD::MissingET object searched for in the composition map.

Definition at line 56 of file MissingETComponentMap_v1.cxx.

 {
   iterator fCont(this->begin());
   iterator lCont(this->end());
   while ( fCont != lCont && (*fCont)->metObject() != pMET ) { ++fCont; }
   return fCont;
 }

◆ find() [2/6]

MissingETComponentMap_v1::const_iterator MissingETComponentMap_v1::find ( const MissingET * pMET ) const

Find MET object referenced by pointer.

Returns: Const iterator referencing a non-modifiable xAOD::MissingETComponent_v1 object linking to the given MET object. If the MET object is not in the ccomposition map, an end const iterator is returned.

Parameters

[in] pMET pointer to the xAOD::MissingET object searched for in the composition map.

Definition at line 48 of file MissingETComponentMap_v1.cxx.

 {
   const_iterator fCont(this->begin());
   const_iterator lCont(this->end());
   while ( fCont != lCont && (*fCont)->metObject() != pMET ) { ++fCont; }
   return fCont;
 }

◆ find() [3/6]

MissingETComponentMap_v1::iterator MissingETComponentMap_v1::find ( const std::string & name )

Find MET object referenced by name.

Returns: Iterator referencing a modifiable xAOD::MissingETComponent_v1 object linking to the given MET object. If the MET object is not in the ccomposition map, an end iterator is returned.

Parameters

[in] name reference to non-modifiable string storing the name of the xAOD::MissingET object searched for.

Note: It is generally expected that the name of the xAOD::MissingET object is unique for this composition. If not, the iterator referencing the first
xAOD::MissingETComponent_v1 object containing a link to a xAOD::MissingET object with the requested name is returned.

Definition at line 72 of file MissingETComponentMap_v1.cxx.

 {
   iterator fCont(this->begin());
   iterator lCont(this->end());
   while ( fCont != lCont && (*fCont)->metObject()->name() != name ) { ++fCont; }
   return fCont;
 }

◆ find() [4/6]

MissingETComponentMap_v1::const_iterator MissingETComponentMap_v1::find ( const std::string & name ) const

Find MET object referenced by name.

Returns: Const iterator referencing a non-modifiable xAOD::MissingETComponent_v1 object linking to the given MET object. If the MET object is not in the ccomposition map, an end const iterator is returned.

Parameters

[in] name reference to non-modifiable string storing the name of the xAOD::MissingET object searched for.

Note: It is generally expected that the name of the xAOD::MissingET object is unique for this composition. If not, the iterator referencing the first
xAOD::MissingETComponent_v1 object containing a link to a xAOD::MissingET object with the requested name is returned.

Definition at line 64 of file MissingETComponentMap_v1.cxx.

 {
   const_iterator fCont(this->begin());
   const_iterator lCont(this->end());
   while (fCont != lCont && (*fCont)->metObject()->name() != name ) { ++fCont; }
   return fCont;
 }

◆ find() [5/6]

MissingETComponentMap_v1::iterator MissingETComponentMap_v1::find ( MissingETBase::Types::bitmask_t src )

Find MET object referenced by source indicator.

Returns: Iterator referencing a modifiable xAOD::MissingETComponent_v1 object linking to the given MET object. If the MET object is not in the ccomposition map, an end iterator is returned.

Parameters

[in] src bit pattern with the requested source indicator.

Note: It is generally expected that the source of the xAOD::MissingET object is unique for this composition. If not, the iterator referencing the first
xAOD::MissingETComponent_v1 object containing a link to a xAOD::MissingET object with the requested source is returned.

Definition at line 88 of file MissingETComponentMap_v1.cxx.

 {
   iterator fCont(this->begin());
   iterator lCont(this->end());
   while ( fCont != lCont && (*fCont)->metObject()->source() != src ) { ++fCont; }
   return fCont;
 }

◆ find() [6/6]

MissingETComponentMap_v1::const_iterator MissingETComponentMap_v1::find ( MissingETBase::Types::bitmask_t src ) const

Find MET object referenced by source indicator.

Returns: Const iterator referencing a non-modifiable xAOD::MissingETComponent_v1 object linking to the given MET object. If the MET object is not in the ccomposition map, an end const iterator is returned.

Parameters

[in] src bit pattern with the requested source indicator.

Note: It is generally expected that the source of the xAOD::MissingET object is unique for this composition. If not, the iterator referencing the first
xAOD::MissingETComponent_v1 object containing a link to a xAOD::MissingET object with the requested source is returned.

Definition at line 80 of file MissingETComponentMap_v1.cxx.

 {
   const_iterator fCont(this->begin());
   const_iterator lCont(this->end());
   while ( fCont != lCont && (*fCont)->metObject()->source() != src ) { ++fCont; }
   return fCont;
 }

◆ findIndex() [1/3]

size_t MissingETComponentMap_v1::findIndex ( const MissingET * pMET ) const

Definition at line 96 of file MissingETComponentMap_v1.cxx.

 {
   const_iterator fCont(this->begin());
   const_iterator lCont(this->end());
   while ( fCont != lCont && (*fCont)->metObject() != pMET ) { ++fCont; }
   if ( fCont != lCont ) return (size_t)std::distance<const_iterator>(this->begin(),fCont);
   return MissingETBase::Numerical::invalidIndex();
 }

◆ findIndex() [2/3]

size_t MissingETComponentMap_v1::findIndex ( const std::string & name ) const

Definition at line 105 of file MissingETComponentMap_v1.cxx.

 {
   const_iterator fCont(this->begin());
   const_iterator lCont(this->end());
   while ( fCont != lCont && (*fCont)->metObject()->name() != name ) { ++fCont; }
   if ( fCont != lCont ) return (size_t)std::distance<const_iterator>(this->begin(),fCont);
   return MissingETBase::Numerical::invalidIndex();
 }

◆ findIndex() [3/3]

size_t MissingETComponentMap_v1::findIndex ( MissingETBase::Types::bitmask_t src ) const

Definition at line 114 of file MissingETComponentMap_v1.cxx.

 {
   const_iterator fCont(this->begin());
   const_iterator lCont(this->end());
   while ( fCont != lCont && (*fCont)->metObject()->source() != src ) { ++fCont; }
   if ( fCont != lCont ) return (size_t)std::distance<const_iterator>(this->begin(),fCont);
   return MissingETBase::Numerical::invalidIndex();
 }

◆ front() [1/2]

ElementProxy DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::front

inherited

Access the first element in the collection as an lvalue.

Returns: Proxy to the first element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ front() [2/2]

const MissingETComponent_v1 * DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::front

inherited

Access the first element in the collection as an rvalue.

Returns: The first element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a const T* rather than a reference.

◆ get()

const MissingETComponent_v1 * DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::get ( size_type n ) const

inherited

Access an element, as an rvalue.

Parameters

n	Array index to access.

Returns: The element at n.

This is a synonym for operator[] const, to be used when calling from root (where we can't readily call just the const version of a method).

◆ getComponentIndex()

size_t MissingETComponentMap_v1::getComponentIndex ( const IParticle * pPart ) const

Definition at line 368 of file MissingETComponentMap_v1.cxx.

368 { return f_getIndex<0>(pPart); }

◆ getObjectIndex()

size_t MissingETComponentMap_v1::getObjectIndex ( const IParticle * pPart ) const

Definition at line 369 of file MissingETComponentMap_v1.cxx.

369 { return f_getIndex<1>(pPart); }

◆ insert() [1/5]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::insert	(	iterator	position,
		InputIterator	first,
		InputIterator	last
	)

inherited

Add a group of new elements to the collection.

Parameters

position	Iterator before which the element will be added.
first	The start of the range to put in the container.
last	The end of the range to put in the container.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

This overload is for the case where the iterator value type is convertible to T*.

◆ insert() [2/5]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::insert	(	iterator	position,
		InputIterator	first,
		InputIterator	last
	)

inherited

Add a group of new elements to the collection.

Parameters

position	Iterator before which the element will be added.
first	The start of the range to put in the container.
last	The end of the range to put in the container.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

This overload is for the case where the iterator value type is convertible to unique_ptr<T>.

◆ insert() [3/5]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::insert	(	iterator	position,
		std::initializer_list< value_type >	l
	)

inherited

Add a group of new elements to the collection.

Parameters

position	Iterator before which the element will be added.
l	An initializer list.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ insert() [4/5]

iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::insert	(	iterator	position,
		std::unique_ptr< base_value_type >	pElem
	)

inherited

Add a new element to the collection.

Parameters

position	Iterator before which the element will be added.
pElem	The element to add to the collection.

Returns: An iterator that points to the inserted data.

The container must be an owning container.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ insert() [5/5]

iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::insert	(	iterator	position,
		value_type	pElem
	)

inherited

Add a new element to the collection.

Parameters

position	Iterator before which the element will be added.
pElem	The element to add to the collection.

Returns: An iterator that points to the inserted data.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ insertMove()

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::insertMove	(	iterator	position,
		DataVector< MissingETComponent_v1 > &	other
	)

inherited

Insert the contents of another DataVector, with auxiliary data copied via move semantics.

Parameters

position	Iterator before which the new elements will be added.
other	The vector to add.

The ownership mode of this vector must be the same as other; otherwise, an exception will be thrown.

If both vectors are view vectors, then this is the same as insert (position, other.begin(), other.end()) .

Otherwise, the elements from other will be inserted into this vector. This vector will take ownership of the elements, and the ownership mode of other will be changed to VIEW_ELEMENTS. Auxiliary data for these elements will be transferred, using move semantics if possible. (Thus, the auxiliary store for other may be modified and must not be locked.) Finally, the auxiliary store pointer for other will be cleared (but the store itself will not be deleted since it's not owned by the vector).

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ iter_swap()

static void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::iter_swap	(	iterator	a,
		iterator	b
	)

staticinherited

Swap the referents of two DataVector iterators.

Parameters

a	The first iterator for the swap.
b	The second iterator for the swap.

◆ max_size()

size_type DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::max_size

noexceptinherited

Returns the size() of the largest possible collection.

◆ operator[]() [1/2]

ElementProxy DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::operator[] ( size_type n )

inherited

Access an element, as an lvalue.

Parameters

n	Array index to access.

Returns: Proxy to the element at n.

No bounds checking is done. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ operator[]() [2/2]

const MissingETComponent_v1 * DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::operator[] ( size_type n ) const

inherited

Access an element, as an rvalue.

Parameters

n	Array index to access.

Returns: The element at n.

No bounds checking is done. Note that we return a const T* rather than a reference.

◆ ownPolicy()

SG::OwnershipPolicy DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::ownPolicy

inherited

Return the ownership policy setting for this container.

◆ pop_back()

void xAOD::MissingETComponentMap_v1::pop_back ( )

◆ push_back() [1/2]

value_type DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::push_back ( std::unique_ptr< base_value_type > pElem )

inherited

Add an element to the end of the collection.

Parameters

pElem The element to add to the collection.

The container must be an owning container.

Note: this method may only be called using the most derived DataVector in the hierarchy.

Returns the pushed pointer.

◆ push_back() [2/2]

value_type DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::push_back ( value_type pElem )

inherited

Add an element to the end of the collection.

Parameters

pElem The element to add to the collection.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

Returns the pushed pointer.

◆ rbegin() [1/2]

const_reverse_iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::rbegin

noexceptinherited

Return a const_reverse_iterator pointing past the end of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ rbegin() [2/2]

reverse_iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::rbegin

noexceptinherited

Return a reverse_iterator pointing past the end of the collection.

Returns: A reverse_iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ rend() [1/2]

const_reverse_iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::rend

noexceptinherited

Return a const_reverse_iterator pointing at the beginning of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ rend() [2/2]

reverse_iterator DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::rend

noexceptinherited

Return a reverse_iterator pointing at the beginning of the collection.

Returns: A reverse_iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ reserve()

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::reserve ( size_type n )

inherited

Attempt to preallocate enough memory for a specified number of elements.

Parameters

n	Number of elements required.

◆ resize()

void xAOD::MissingETComponentMap_v1::resize ( size_type sz )

◆ resortAux()

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::resortAux	(	iterator	beg,
		iterator	end
	)

inherited

Reset indices / reorder aux data after elements have been permuted.

Parameters

beg	Start of the range of elements to process.
end	End of the range of elements to process.

Call this after some operation that has permuted the elements in the container (such as sort). The index information in the elements will be used to permute all auxiliary data in the same way. Finally, all the indices will be reset in the correct order.

◆ retrieveMissingET() [1/3]

const MissingET * MissingETComponentMap_v1::retrieveMissingET ( const std::string & name ) const

Retrieve MissingET object by name.

Returns: Valid pointer to MissingET typed object representing a MET term. If the requested object cannot be found, NULL is returned.

Parameters

[in] name reference to non-modifiable dataword holding the name of the requested MET object.

Definition at line 127 of file MissingETComponentMap_v1.cxx.

 {
   const_iterator fCont(this->begin());
   const_iterator lCont(this->end());
   while ( fCont != lCont && (*fCont)->metObject()->name() != name ) { ++fCont; }
   if ( fCont != lCont ) return (*fCont)->metObject();
   return nullptr;
 }

◆ retrieveMissingET() [2/3]

const MissingET * MissingETComponentMap_v1::retrieveMissingET	(	MissingETBase::Types::bitmask_t	src,
		bool	excl = `false`
	)		const

Retrieve MissingET object by source indicator.

Returns: Valid pointer to MissingET typed object representing a MET term. If the requested object cannot be found, NULL is returned.

Parameters

[in]	src	bit pattern defining the source of the requested MET object.
[in]	excl	flag controlling the bit pattern test - if `false`, the pointer to the first MET object found with a source indicator containing the requested bit pattern is returned; if `true`, the first MET object found with exactly the requested bit pattern as a source indicator is returned.

Definition at line 136 of file MissingETComponentMap_v1.cxx.

137 { return excl ? this->f_retrieveMissingETExcl(src) : this->f_retrieveMissingETIncl(src); }

◆ retrieveMissingET() [3/3]

const MissingET * MissingETComponentMap_v1::retrieveMissingET	(	MissingETBase::Types::bitmask_t	src,
		MissingETBase::Types::bitmask_t	sw,
		bool	excl = `false`
	)		const

Retrieve MissingET object by source indicator and status word.

Parameters

[in] sw bit pattern defining the status of the MET contribution linking to the requested MET object.

Note: While the MissingET object name should be unique within a given MET composition, MET objects can have the same source with a different contribution status. This method supports a query for a MET object with a given source/status combination.

Definition at line 139 of file MissingETComponentMap_v1.cxx.

140 { return excl ? this->f_retrieveMissingETExcl(src,sw) : this->f_retrieveMissingETIncl(src,sw); }

◆ setClusters()

bool MissingETComponentMap_v1::setClusters	(	const MissingET *	pMET,
		const IParticle *	pPart,
		const MissingETBase::Types::object_vector_t &	signalList
	)

Definition at line 276 of file MissingETComponentMap_v1.cxx.

 {
   // find all clusters
   // check input: MissingET object pointer
   size_t cIdx(this->findIndex(pMET)); if ( cIdx == MissingETBase::Numerical::invalidIndex() ) { return false; }
   // check input: contributing particle pointer
   size_t pIdx(this->at(cIdx)->findIndex(pPart)); if ( pIdx == MissingETBase::Numerical::invalidIndex()  ) { return false; }
   indexedlink_t ld(cIdx,pIdx); 
   // make sure cache is not cleared
   bool firstCluster = true;
   MissingETBase::Types::object_vector_t::const_iterator fSig(signalList.begin());
   MissingETBase::Types::object_vector_t::const_iterator lSig(signalList.end());
   for ( ; fSig != lSig; ++fSig ) {
     if((*fSig)->type()==xAOD::Type::CaloCluster) {
       if(firstCluster) {
     firstCluster = false;
     if ( m_clusterLinks.empty() )  { 
       const IParticleContainer* pCont(static_cast<const IParticleContainer*>((*fSig)->container()));
       // if ( pCont == 0 )
       //   { printf("MissingETComponentMap::setClusters(...) - WARNING   - cannot access cluster container (invalid NULL pointer), use %i words\n",(int)nClus); }
       // else
       m_clusterLinks.resize(pCont->size(), MissingETBase::Numerical::invalidLink());
     } // empty cluster link list
       } //first cluster
       // all clusters refer to the same MET contribution
       m_clusterLinks[(*fSig)->index()] = ld;
     } // extract CaloClusters
   } // loop over signal list
  
   return !firstCluster; // true if we processed any clusters
 }

◆ setMostDerived()

virtual void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::setMostDerived

protectedvirtualinherited

Set m_isMostDerived for this instance and clear it for all bases.

Called from testInsert if the test fails. The flag may not have been set if this container was made via copy construction, so set it appropriately now so we can test again.

◆ setObjects()

bool MissingETComponentMap_v1::setObjects	(	const MissingET *	pMET,
		const IParticle *	pPart,
		const MissingETBase::Types::object_vector_t &	objectList
	)

Definition at line 340 of file MissingETComponentMap_v1.cxx.

 {
   // check input: MissingET object pointer
   size_t cIdx(this->findIndex(pMET)); if ( cIdx == MissingETBase::Numerical::invalidIndex() ) { return false; }
   // loop input objects
   size_t oldSize(m_particleLinks.size());
   MissingETBase::Types::object_vector_t::const_iterator fObj(objects.begin());
   MissingETBase::Types::object_vector_t::const_iterator lObj(objects.end());
   for ( ; fObj != lObj; ++fObj ) { size_t pIdx(this->at(cIdx)->findIndex(pPart)); m_particleLinks[*fObj] = indexedlink_t(cIdx,pIdx); }
   //
   return oldSize < m_particleLinks.size();
 } 

◆ setTracks()

bool MissingETComponentMap_v1::setTracks	(	const MissingET *	pMET,
		const IParticle *	pPart,
		const MissingETBase::Types::object_vector_t &	signalList
	)

Definition at line 308 of file MissingETComponentMap_v1.cxx.

 {
   // find all clusters
   // check input: MissingET object pointer
   size_t cIdx(this->findIndex(pMET)); if ( cIdx == MissingETBase::Numerical::invalidIndex() ) { return false; }
   // check input: contributing particle pointer
   size_t pIdx(this->at(cIdx)->findIndex(pPart)); if ( pIdx == MissingETBase::Numerical::invalidIndex()  ) { return false; }
   indexedlink_t ld(cIdx,pIdx); 
   // make sure cache is not cleared
   bool firstTrack = true;
   MissingETBase::Types::object_vector_t::const_iterator fSig(signalList.begin());
   MissingETBase::Types::object_vector_t::const_iterator lSig(signalList.end());
   for ( ; fSig != lSig; ++fSig ) {
     if((*fSig)->type()==xAOD::Type::TrackParticle) {
       if(firstTrack) {
     firstTrack = false;
     if ( m_trackLinks.empty() ) { 
       const IParticleContainer* pCont(static_cast<const IParticleContainer*>((*fSig)->container()));
       // if ( pCont == 0 )
       //   { printf("MissingETComponentMap::setTracks(...) - WARNING   - cannot access track container (invalid NULL pointer), use %i words\n",(int)nTrack); }
       // else
       m_trackLinks.resize(pCont->size(), MissingETBase::Numerical::invalidLink());
     } // empty track link list
       } // first track
       // all tracks refer to the same MET contribution
       m_trackLinks[(*fSig)->index()] = ld;
     } // extract TrackParticles
   } // loop over signal list
  
   return !firstTrack; // true if we processed any clusters
 }

◆ shift()

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::shift	(	size_t	pos,
		ptrdiff_t	offs
	)

privateinherited

Shift the auxiliary elements of the container.

Parameters

pos	The starting index for the shift.
offs	The (signed) amount of the shift.

The elements in the container should have already been shifted; this operation will then adjust the element indices and also shift the elements in the vectors for all aux data items. offs may be either positive or negative.

If offs is positive, then the container is growing. The container size should be increased by offs, the element at pos moved to pos + offs, and similarly for following elements. The elements between pos and pos + offs should be default-initialized.

If offs is negative, then the container is shrinking. The element at pos should be moved to pos + offs, and similarly for following elements. The container should then be shrunk by -offs elements (running destructors as appropriate).

◆ shrink_to_fit()

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::shrink_to_fit

inherited

◆ size()

size_type DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::size

noexceptinherited

Returns the number of elements in the collection.

Could in principle be inherited from the base class, but redeclared in the derived class to avoid root6 bugs.

◆ sort() [1/2]

void xAOD::MissingETComponentMap_v1::sort ( )

◆ sort() [2/2]

template<class COMPARE >

void xAOD::MissingETComponentMap_v1::sort ( COMPARE comp )

◆ stdcont()

const PtrVector & DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::stdcont

inherited

Return the underlying std::vector of the container.

Returns: Reference to the std::vector actually holding the collection.

Note that DataVector<T>::stdcont does not necessarily return a std::vector<T*> if DataVector inheritance is being used.

◆ swap()

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::swap ( DataVector< MissingETComponent_v1 > & rhs )

inherited

Swap this collection with another.

Parameters

rhs	The collection with which to swap.

Ownership is swapped along with the collection content.

Note: this method may only be called using the most-derived DataVector in the hierarchy. The rhs must also be referenced using the most-derived DataVector.

◆ swapElement() [1/4]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::swapElement	(	iterator	pos,
		std::unique_ptr< base_value_type >	newElem,
		std::unique_ptr< base_value_type > &	oldElem
	)

inherited

Swap one element out of the container.

Parameters

pos	The element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element pos of the collection (no bounds checking). Then element index is set to newElem.

The collection must own its elements to use its interface. The collection will take ownership of newElem and will return ownership of oldElem.

Note: this method may only be called using the most derived DataList in the hierarchy.

◆ swapElement() [2/4]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::swapElement	(	iterator	pos,
		value_type	newElem,
		reference	oldElem
	)

inherited

Swap one element out of the container.

Parameters

pos	The element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element pos of the collection (no bounds checking). Then element index is set to newElem. If the collection owns its elements, then it will take ownership of newElem and release (without deleting) the element returned through oldElem.

Note: this method may only be called using the most derived DataList in the hierarchy.

◆ swapElement() [3/4]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::swapElement	(	size_type	index,
		std::unique_ptr< base_value_type >	newElem,
		std::unique_ptr< base_value_type > &	oldElem
	)

inherited

Swap one element out of the container.

Parameters

index	Index of the element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element index of the collection (no bounds checking). Then element index is set to newElem.

The collection must own its elements to use its interface. The collection will take ownership of newElem and will return ownership of oldElem.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ swapElement() [4/4]

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::swapElement	(	size_type	index,
		value_type	newElem,
		reference	oldElem
	)

inherited

Swap one element out of the container.

Parameters

index	Index of the element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element index of the collection (no bounds checking). Then element index is set to newElem. If the collection owns its elements, then it will take ownership of newElem and release (without deleting) the element returned through oldElem.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ testInsert()

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::testInsert ( const char * op )

inherited

Test if we can insert; raise an exception if not.

Parameters

op	Description of the attempted operation.

In order to maintain type-safety, we can only allow insertions using the most-derived instance of DataVector. This checks this by testing the m_isMostDerived, which is set by the constructors to true only for the most-derived instance. If the test fails, we call to potentially out-of-line code to continue.

◆ testInsertOol()

void DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::testInsertOol ( const char * op )

inherited

Test if we can insert; raise an exception if not.

Parameters

op	Description of the attempted operation.

This continues the test of testInsert. There is one case where m_isMostDerived may not be set correctly. If this container was made via copy construction, then all the m_isMostDerived flags will be false. So we call setMostDerived to set the flags correctly and test again. If the test fails again, then we raise an exception.

Member Data Documentation

◆ has_virtual

const bool DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::has_virtual

staticinherited

This is true for any DataVector class if we need to use virtual derivation to get to the base DataVector class.

Definition at line 801 of file DataVector.h.

◆ m_clusterLinkReserve

const size_t xAOD::MissingETComponentMap_v1::m_clusterLinkReserve =10000

staticprivate

Definition at line 293 of file MissingETComponentMap_v1.h.

◆ m_clusterLinks

signal_vector_t xAOD::MissingETComponentMap_v1::m_clusterLinks

protected

Store for linked cluuster signal information lookup.

In case of a signal (xAOD::CaloCluster, xAOD::TrackParticle) object look-up, the index of these objects can be directly used to check if they have already been used in the actual MET composition (random access in this index parallel store - with respect to the actual xAOD::CaloClusterContainer and the xAOD::TrackParticleContainer).

Definition at line 212 of file MissingETComponentMap_v1.h.

◆ m_isMostDerived

SG::IsMostDerivedFlag DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::m_isMostDerived

privateinherited

This flag is true if this DV instance is the most-derived one.

We set this to true in the top-level constructor; the constructor then calls clearMostDerived on the base classes.

Definition at line 2038 of file DataVector.h.

◆ m_particleLinks

particle_map_t xAOD::MissingETComponentMap_v1::m_particleLinks

protected

Store for linked physics object information lookup.

In case of physics objects, a map look-up is implemented as the lack of a common container for these objects does not allow using the index as a unique key. The object pointer is used instead, and the look-up is provided by a standard map (binary search). Typically, the number of entries in this map is rather small (much less than 100) so that this storage technology should not introduce performance problems.

Definition at line 218 of file MissingETComponentMap_v1.h.

◆ m_trackLinkReserve

const size_t xAOD::MissingETComponentMap_v1::m_trackLinkReserve =10000

staticprivate

Definition at line 294 of file MissingETComponentMap_v1.h.

◆ m_trackLinks

signal_vector_t xAOD::MissingETComponentMap_v1::m_trackLinks

protected

Store for linked track signal information lookup.

In case of a signal (xAOD::CaloCluster, xAOD::TrackParticle) object look-up, the index of these objects can be directly used to check if they have already been used in the actual MET composition (random access in this index parallel store - with respect to the actual xAOD::CaloClusterContainer and the xAOD::TrackParticleContainer).

Definition at line 215 of file MissingETComponentMap_v1.h.

◆ must_own

constexpr bool DataVector< MissingETComponent_v1 , typename DataVectorBase<MissingETComponent_v1 >::Base >::must_own

staticconstexprinherited

If true, then this type must own its contents.

Definition at line 859 of file DataVector.h.

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

Public Types

Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Swap and sort.

Non-standard operations.

Internal operations.

Internal object lookup cache handlers

Detailed Description

Member Typedef Documentation

◆ allocator_type

◆ base_data_vector

◆ base_value_type

◆ BaseContainer

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ const_reverse_iterator

◆ const_value_type

◆ DataVector_BASE

◆ Deleter

◆ difference_type

◆ DVL_BASE

◆ ElementProxy

◆ indexedlink_t

◆ iterator

◆ particle_key_t

◆ particle_map_t

◆ pointer

◆ PtrVector

◆ reference

◆ reverse_iterator

◆ self

◆ signal_key_t

◆ signal_vector_t

◆ size_type

◆ unique_type

◆ value_type

Constructor & Destructor Documentation

◆ MissingETComponentMap_v1() [1/2]

◆ MissingETComponentMap_v1() [2/2]

◆ ~MissingETComponentMap_v1()

Member Function Documentation

◆ addObjects()

◆ assign() [1/2]

◆ assign() [2/2]

◆ assignBaseElement()

◆ assignElement() [1/2]

◆ assignElement() [2/2]

◆ at() [1/2]

◆ at() [2/2]

◆ auxbase()

◆ back() [1/2]

◆ back() [2/2]

◆ baseOffset()

◆ baseOffset1()

◆ begin() [1/2]

◆ begin() [2/2]

◆ capacity()

◆ cbegin()

◆ cend()

◆ checkUsage() [1/2]

◆ checkUsage() [2/2]

◆ clear() [1/4]

◆ clear() [2/4]

◆ clear() [3/4]

◆ clear() [4/4]

◆ clearMostDerived()

◆ crbegin()

◆ crend()

◆ do_cast()

◆ do_cast_nc()

◆ dv_typeid()

◆ dvlinfo()

◆ dvlinfo_v()

◆ emplace()

◆ emplace_back()

◆ empty()