xAOD::MissingETComposition Struct Reference

Collection of functions managing the MET composition map and association map. More...

#include <MissingETComposition.h>

Static Public Member Functions
template<int OBJTYPE>
static bool	fillMissingET (const MissingETComponentMap pMap, MissingET pMET, MissingETBase::Types::bitmask_t=MissingETBase::Status::clearedStatus())
	Fill a given MissingET object.
Adding data to the composition map

static bool	add (MissingETComponentMap pMap, const MissingET pMET, MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus())
	Adding a MissingET object to the map.
static bool	insert (MissingETComponentMap pMap, const MissingET pMET, const IParticle *pPart, MissingETBase::Types::weight_t weight=MissingETBase::Types::weight_t())
	Insert contributing signal or physics object by pointer, with optional kinematic weight object.
static bool	insert (MissingETComponentMap pMap, const MissingET pMET, const IParticle *pPart, const MissingETBase::Types::object_vector_t &signalList, MissingETBase::Types::weight_t weight=MissingETBase::Types::weight_t(), MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster)
	Insert MET object and contributing object by pointers, with list of signals and optional kinematic weight object.
static bool	insert (MissingETComponentMap pMap, const MissingET pMET, const IParticle *pPart, double wpx, double wpy, double wet)
	Insert MET object and contributing object by pointers, with individual weights.
static bool	insert (MissingETComponentMap pMap, const MissingET pMET, const IParticle *pPart, const MissingETBase::Types::object_vector_t &signalList, double wpx, double wpy, double wet, MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster)
	Insert MET object and contributing object by pointers, with list of signals and individual weight components.
static bool	updateLinks (MissingETComponentMap *pMap)
	Update all ElementLinks in all contributions.
static bool	updateMETLinks (MissingETComponentMap *pMap)
	Update all ElementLinks to MET objects only in all contributions.
Find a contributing particle

static MissingETComponentMap::const_iterator	find (const MissingETComponentMap pMap, const MissingET pmetObj)
	Find non-modifiable contribution for a given MET object.
static MissingETComponentMap::iterator	find (MissingETComponentMap pMap, const MissingET pmetObj)
static MissingETComponentMap::const_iterator	find (const MissingETComponentMap *pMap, const std::string &metName)
static MissingETComponentMap::iterator	find (MissingETComponentMap *pMap, const std::string &metName)
static MissingETComponentMap::const_iterator	find (const MissingETComponentMap *pMap, MissingETBase::Types::bitmask_t src)
static MissingETComponentMap::iterator	find (MissingETComponentMap *pMap, MissingETBase::Types::bitmask_t src)
static size_t	findIndex (const MissingETComponentMap pMap, const MissingET pmetObj)
static size_t	findIndex (const MissingETComponentMap *pMap, const std::string &metName)
static size_t	findIndex (const MissingETComponentMap *pMap, MissingETBase::Types::bitmask_t src)
static MissingETComponentMap::const_iterator	find (const MissingETComponentMap pMap, const IParticle pPart)
	Find non-modifiable contribution for given particle.
static MissingETComponentMap::iterator	find (MissingETComponentMap pMap, const IParticle pPart)
	Find modifiable contribution for given particle.
static MissingETAssociationMap::const_iterator	find (const MissingETAssociationMap pMap, const Jet pJet)
	Find non-modifiable contribution for a given MET object.
static MissingETAssociationMap::iterator	find (MissingETAssociationMap pMap, const Jet pJet)
static MissingETAssociationMap::const_iterator	find (const MissingETAssociationMap pMap, const IParticle pPart)
	Find non-modifiable contribution for given particle.
static MissingETAssociationMap::iterator	find (MissingETAssociationMap pMap, const IParticle pPart)
	Find modifiable contribution for given particle.
Access contribution

static MissingETComponentMap::const_iterator	begin (const MissingETComponentMap *pMap)
	Const iterator access to beginning of composition map.
static MissingETComponentMap::iterator	begin (MissingETComponentMap *pMap)
	Iterator access to beginning of composition map.
static MissingETComponentMap::const_iterator	end (const MissingETComponentMap *pMap)
static MissingETComponentMap::iterator	end (MissingETComponentMap *pMap)
static const MissingETComponent *	getComponent (const MissingETComponentMap pMap, const IParticle pPart)
	Access non-modifiable contribution object.
static const MissingETComponent *	getComponent (const MissingETComponentMap pMap, const MissingET pmetObj)
static const MissingETComponent *	getComponent (const MissingETComponentMap *pMap, const std::string &metName)
static const MissingETComponent *	getComponent (const MissingETComponentMap *pMap, MissingETBase::Types::bitmask_t src)
static MissingETComponent *	getComponent (MissingETComponentMap pMap, const IParticle pPart)
	Access non-modifiable contribution object.
static MissingETComponent *	getComponent (MissingETComponentMap pMap, const MissingET pmetObj)
static MissingETComponent *	getComponent (MissingETComponentMap *pMap, const std::string &metName)
static MissingETComponent *	getComponent (MissingETComponentMap *pMap, MissingETBase::Types::bitmask_t src)
static std::vector< const MissingETAssociation * >	getAssociations (const MissingETAssociationMap pMap, const IParticle pPart)
	Access non-modifiable contribution object.
static MissingETBase::Types::constvec_t	getConstVec (const MissingETAssociationMap pMap, const IParticle pPart, MissingETBase::UsageHandler::Policy p)
static bool	objSelected (const MissingETAssociationMap pMap, const IParticle obj)
static bool	selectIfNoOverlaps (const MissingETAssociationMap pMap, const IParticle obj, MissingETBase::UsageHandler::Policy p)
static const MissingETAssociation *	getAssociation (const MissingETAssociationMap pMap, const Jet pJet)
static std::vector < MissingETAssociation * >	getAssociations (MissingETAssociationMap pMap, const IParticle pPart)
	Access non-modifiable contribution object.
static MissingETAssociation *	getAssociation (MissingETAssociationMap pMap, const Jet pJet)
Access contribution parameters and linked objects

static MissingETBase::Types::weight_t	getWeight (const MissingETComponentMap pMap, const IParticle pPart)
static MissingETBase::Types::weight_t	getWeight (MissingETComponentMap::const_iterator fCont, const IParticle *pPart)
static MissingETBase::Types::bitmask_t	getStatusWord (const MissingETComponentMap pMap, const MissingET pmetObj)
static MissingETBase::Types::bitmask_t	getStatusWord (MissingETComponentMap::const_iterator fCont)
static const MissingET *	getMissingET (const MissingETComponentMap pMap, const IParticle pPart)
static const MissingET *	getMissingET (MissingETComponentMap::const_iterator fCont)
static const MissingET *	getMissingET (const MissingETComponentMap *pMap, const std::string &name)
static const MissingET *	getMissingET (const MissingETComponentMap *pMap, MissingETBase::Types::bitmask_t sw)
static const Jet *	getRefJet (const MissingETAssociationMap pMap, const IParticle pPart)
static const Jet *	getRefJet (MissingETAssociationMap::const_iterator fCont)
Adding data to the association map

static bool	add (MissingETAssociationMap pMap, const Jet pJet, const std::vector< ElementLink< IParticleContainer > > &jetconst=std::vector< ElementLink< IParticleContainer > >(), const MissingETBase::Types::constvec_t &trkvec=MissingETBase::Types::constvec_t())
	Adding a Jet object to the map.
static bool	add (MissingETAssociationMap pMap, const Jet pJet, const std::vector< const IParticle * > &jetracks=std::vector< const IParticle * >())
	Adding a Jet object to the map.
static bool	addMiscAssociation (MissingETAssociationMap *pMap)
	Add an association to hold objects not associated to any jet.
static bool	insert (MissingETAssociationMap pMap, size_t jetIndex, const IParticle pPart, const std::vector< const IParticle * > &constlist)
	Insert contributing object to jet referenced by index, with constVecs for track and calo constituents.
static bool	insert (MissingETAssociationMap pMap, const Jet pJet, const IParticle pPart, const std::vector< const IParticle > &constlist)
	Insert contributing object to jet referenced by pointer, with constVecs for track and calo constituents.
static bool	insert (MissingETAssociationMap pMap, const IParticle pPart, const std::vector< const IParticle * > &constlist, std::map< const IParticle , MissingETBase::Types::constvec_t > pOverride=std::map< const IParticle , MissingETBase::Types::constvec_t >())
	Insert contributing object, finding the appropriate association automatically.
static bool	setJetConstSum (MissingETAssociationMap metMap, const Jet jet, const std::vector< const IParticle * > &altConsts, std::map< const IParticle *, MissingETBase::Types::constvec_t > pOverride)
static bool	insertMisc (MissingETAssociationMap pMap, const IParticle pPart, const std::vector< const IParticle * > &constlist)
	Insert contributing object into miscellaneous association.

Detailed Description

Collection of functions managing the MET composition map and association map.

Preliminaries

This struct does not contain any private data, and does not support any storable data. It collects functions interacting with the data objects providing the composition of a given missing transverse momentum (MET) reconstruction configuration. One set of these data objects includes MissingETComponent for the description of the contributions to a given MET, and MissingETComponentMap , which collects all contributions to a full and consistent MET and thus describes its configuration in terms of contributions from the all physics and signal objects in the event. The other set consists of MissingETAssociation that stores objects matched to a reconstructed jet, and MissingETAssociationMap , which encodes all overlaps between objects in a physics event.

Introduction

The principal data objects describing the composition of a given reconstructed MET are (1) the MissingETComponent object and (2) the MissingETComponentMap object. The first one describes the contributions to a given MET term, as documented here , and the second object is a collection of MET contibutions describing the composition of the fully reconstructed MET.

To permit the rebuilding of MET more easily without recourse to the constituent collections, we define (1) the MissingETAssociation object and (2) the MissingETAssociationMap object. The first one describes the objects matched to a reconstructed jet, as documented here , and the second object is a collection of associations, holding all overlap removal decisions for objects in the event.

The interaction with these data objects and the rules applied to these interactions are provided by the functions collected in the MissingETComposition structure.

Insertion rules (link to code documentation)

Two different levels of

Example: add data to the composition map

Each tool reconstructing a MET term is expected to add a MissingET object to a composition map. The sequence in the tool's execute method should look like this:

   StatusCode METElectronTool::executeTool(xAOD::MissingET* pMET,xAOD::MissingETComponentMap* pMap) {
      const xAOD::EgammaContainer pCont = 0; 
      if ( this->evtStore()->retrieve(pCont,"ElectronContainer").isFailure() ) 
        { ATH_MSG_ERROR("Cannot allocate ElectronContainer"); return StatusCode::FAILURE; }
 
      pMET->setName("METElectron");                        // set name 
      pMET->setSource(MissingETBase::Source::electron());  // set source indicator
      if ( !MissingETComposition::add(pMap,pMET,MissingETBase::Status::electron()) )
        { ATH_MSG_WARNING("MissingET object <" << pMET->name() << " already in composition map"); return StatusCode::SUCCESS; }

      xAOD::EgammaContainer::const_iterator fEle(pCont->begin());
      xAOD::EgammaContainer::const_iterator lEle(pCont->end());
      MissingETBase::MissingETBase::Types::object_vector_t clusterList;

      for ( ; fEle != lEle; ++fEle ) {
        if ( this->filter(*fEle) ) {                                       // select electrons
          clusterList.clear();                                             // accepted electron: clear cluster list
          this->extractClusters(*fEle,clusterList);                        // accepted electron: extract list of clusters associated with the electron      
          if ( !pMap->checkOverlap(clusterList) ) {                        // accepted electron: check for signal overlap
            pMet.add((*fEle)->p4().Px(),(*fEle)->p4().Py(),(*fEle)->pt()); // accepted electron/no overlap: add to MET object  
            MissingETComposition::insert(pMap,pMET,*fEle,clusterList);     // accepted electron/no overlap: add to composition map
          } // no signal overlap
        } // accepted electron
      } // loop on all electrons
   
      return StatusCode::SUCCESS;
    }

In this example MissingETComposition::add(MissingETComponentMap*,const MissingET*,MissingETBase::Types::bitmask_t sw) and MissingETComposition::insert(MissingETComponentMap*,const MissingET*,const MissingETBase::Types::weight_t&) are used.

Member Function Documentation

bool xAOD::MissingETComposition::add	(	MissingETAssociationMap *	pMap,
		const Jet *	pJet,
		const std::vector< const IParticle * > &	jetracks = `std::vector<const IParticle*>()`
	)			`[static]`

Adding a Jet object to the map.

This function should be called for a given Jet object before MissingETComposition::insert is invoked for the same object. Note that the the rules for adding a MET object do not allow to add the same object more than once to a given MissingETAssociationMap .

Returns:: true if the object is not already in the map, else false.

Parameters:

`[in]`	pMap	pointer to modifiable MissingETAssociationMap object (the map to which the Jet object added.
`[in]`	pJet	pointer to non-modifiable Jet object.
`[in]`	jettracks	vector of pointers to tracks associated to jet.

bool xAOD::MissingETComposition::add	(	MissingETAssociationMap *	pMap,
		const Jet *	pJet,
		const std::vector< ElementLink< IParticleContainer > > &	jetconst = `std::vector<ElementLink<IParticleContainer> >()`,
		const MissingETBase::Types::constvec_t &	trkvec = `MissingETBase::Types::constvec_t()`
	)			`[static]`

Adding a Jet object to the map.

This function should be called for a given Jet object before MissingETComposition::insert is invoked for the same object. Note that the the rules for adding a MET object do not allow to add the same object more than once to a given MissingETAssociationMap .

Returns:: true if the object is not already in the map, else false.

Parameters:

`[in]`	pMap	pointer to modifiable MissingETAssociationMap object (the map to which the Jet object added.
`[in]`	pJet	pointer to non-modifiable Jet object.
`[in]`	jetconst	vector of elementlinks to jet constituents.

bool xAOD::MissingETComposition::add	(	MissingETComponentMap *	pMap,
		const MissingET *	pMET,
		MissingETBase::Types::bitmask_t	sw = `MissingETBase::Status::clearedStatus()`
	)			`[static]`

Adding a MissingET object to the map.

This function should be called for a given MissingET object before MissingETComposition::insert is invoked for the same object. Note that the the rules for adding a MET object do not allow to add the same object more than once to a given MissingETComponentMap .

Returns:: true if the object is not already in the map, else false.

Parameters:

`[in]`	pMap	pointer to modifiable MissingETComponentMap object (the map to which the MissingET object added.
`[in]`	pMET	pointer to non-modifiable MissingET object.
`[in]`	sw	bitmask indicating contribution status (optional, default is MissingETBase::Status::clearedStatus())

bool xAOD::MissingETComposition::addMiscAssociation ( MissingETAssociationMap * pMap ) [static]

Add an association to hold objects not associated to any jet.

In some cases, e.g. muons, it's useful to have a dummy association, so that overlap removal can be handled for objects not associated to a jet.

Returns:: true if the object is not already in the map, else false.

Parameters:

[in] pMap pointer to modifiable MissingETAssociationMap object (the map to which the Jet object added.

static MissingETComponentMap::iterator xAOD::MissingETComposition::begin ( MissingETComponentMap * pMap ) [static]

Iterator access to beginning of composition map.

Returns:: Iterator referencing the first entry in MissingETComponentMap . It the map is empty MissingETComposition::end(const MissingETComponentMap*) is returned.

Parameters:

[in] pMap pointer to non-modifiable composition map.

Warning:: Handing a NULL pointer to this function will lead to a program termination (crash).

static MissingETComponentMap::const_iterator xAOD::MissingETComposition::begin ( const MissingETComponentMap * pMap ) [static]

Const iterator access to beginning of composition map.

Returns:: Const iterator referencing the first entry in MissingETComponentMap . It the map is empty MissingETComposition::end(const MissingETComponentMap*) is returned.

Parameters:

[in] pMap pointer to non-modifiable composition map.

Warning:: Handing a NULL pointer to this function will lead to a program termination (crash).

template<int OBJTYPE>

static bool xAOD::MissingETComposition::fillMissingET	(	const MissingETComponentMap *	pMap,
		MissingET *	pMET,
		MissingETBase::Types::bitmask_t	= `MissingETBase::Status::clearedStatus()`
	)			`[inline, static]`

Fill a given MissingET object.

This method fills a referenced MissingET object with kinematics from a specific object type. This method is useful if contributions to a given MET term are of one object type only (basically true for all hard MET terms). For the soft MET term, which may be composed of contributions from tracks and clusters, one could invoke this method twice (once for each object type) for the same MissingET object. The method does not reset the MissingET object, it strictly adds the contributions from objects of the requested type.

Returns:: true if anything added to the referenced MissingET object, else false.

Template Parameters:

OBJTYPE

xAOD::Type::ObjectType requested to contribute to the MET object.

Parameters:

`[in]`	pMET	pointer to modifiable MET object to be updated.
`[in]`	status	statusword filter to be applied as a contribution filter (optional, default is MissingETBase::Status::clearedStatus())

static MissingETAssociationMap::iterator xAOD::MissingETComposition::find	(	MissingETAssociationMap *	pMap,
		const IParticle *	pPart
	)			`[static]`

Find modifiable contribution for given particle.

Returns:: Iterator pointing to non-modifiable MissingETAssociation object linked to given object (particle) if found, else return end iterator. The first occurance is returned, independent of the status of the contribution.

Parameters:

[in] pPart pointer to non-modifiable object possibly contributing to a given MET object.

static MissingETAssociationMap::const_iterator xAOD::MissingETComposition::find	(	const MissingETAssociationMap *	pMap,
		const IParticle *	pPart
	)			`[static]`

Find non-modifiable contribution for given particle.

Returns:: Const iterator pointing to non-modifiable MissingETAssociation object linked to given object (particle) with a given status if found, else return end (const) iterator. The first occurance with a given status is returned.

Parameters:

[in] pPart pointer to non-modifiable object possibly contributing to a given MET object.

MissingETAssociationMap::const_iterator xAOD::MissingETComposition::find	(	const MissingETAssociationMap *	pMap,
		const Jet *	pJet
	)			`[static]`

Find non-modifiable contribution for a given MET object.

Returns:: Const iterator pointing to a non-modifiable MissingETAssociation object linked to given object (particle) if found, else return end (const) iterator. The first occurance is returned, independent of the status of the contribution.

Parameters:

[in] pJet pointer to valid Jet object.

Note:: This method performs a linear search with at most N iterations (N is the number of contributions in the association map).

MissingETAssociationMap::iterator xAOD::MissingETComposition::find	(	MissingETComponentMap *	pMap,
		const IParticle *	pPart
	)			`[static]`

Find modifiable contribution for given particle.

Returns:: Iterator pointing to non-modifiable MissingETComponent object linked to given object (particle) if found, else return end iterator. The first occurance is returned, independent of the status of the contribution.

Parameters:

[in] pPart pointer to non-modifiable object possibly contributing to a given MET object.

MissingETAssociationMap::const_iterator xAOD::MissingETComposition::find	(	const MissingETComponentMap *	pMap,
		const IParticle *	pPart
	)			`[static]`

Find non-modifiable contribution for given particle.

Returns:: Const iterator pointing to non-modifiable MissingETComponent object linked to given object (particle) with a given status if found, else return end (const) iterator. The first occurance with a given status is returned.

Parameters:

[in] pPart pointer to non-modifiable object possibly contributing to a given MET object.

MissingETComponentMap::const_iterator xAOD::MissingETComposition::find	(	const MissingETComponentMap *	pMap,
		const MissingET *	pmetObj
	)			`[static]`

Find non-modifiable contribution for a given MET object.

Returns:: Const iterator pointing to a non-modifiable MissingETComponent object linked to given object (particle) if found, else return end (const) iterator. The first occurance is returned, independent of the status of the contribution.

Parameters:

[in] pmetObj pointer to valid MissingET object.

Note:: This method performs a linear search with at most N iterations (N is the number of contributions in the composition map).

std::vector< MissingETAssociation * > xAOD::MissingETComposition::getAssociations	(	MissingETAssociationMap *	pMap,
		const IParticle *	pPart
	)			`[static]`

Access non-modifiable contribution object.

Returns:: Pointer to modifiable MissingETAssociation object if contribution of referenced object (particle) found, else NULL.

std::vector< const MissingETAssociation * > xAOD::MissingETComposition::getAssociations	(	const MissingETAssociationMap *	pMap,
		const IParticle *	pPart
	)			`[static]`

Access non-modifiable contribution object.

Returns:: Pointer to non-modifiable MissingETAssociation object if contribution of referenced object (particle) found, else NULL.

Parameters:

[in] pPart pointer to non-modifiable object possibly contributing to a given MET object.

MissingETComponent * xAOD::MissingETComposition::getComponent	(	MissingETComponentMap *	pMap,
		const IParticle *	pPart
	)			`[static]`

Access non-modifiable contribution object.

Returns:: Pointer to modifiable MissingETComponent object if contribution of referenced object (particle) found, else NULL.

const MissingETComponent * xAOD::MissingETComposition::getComponent	(	const MissingETComponentMap *	pMap,
		const IParticle *	pPart
	)			`[static]`

Access non-modifiable contribution object.

Returns:: Pointer to non-modifiable MissingETComponent object if contribution of referenced object (particle) found, else NULL.

Parameters:

[in] pPart pointer to non-modifiable object possibly contributing to a given MET object.

bool xAOD::MissingETComposition::insert	(	MissingETAssociationMap *	pMap,
		const IParticle *	pPart,
		const std::vector< const IParticle * > &	constlist,
		std::map< const IParticle *, MissingETBase::Types::constvec_t >	pOverride = `std::map<const IParticle*,MissingETBase::Types::constvec_t>()`
	)			`[static]`

Insert contributing object, finding the appropriate association automatically.

Returns:: true if insertion successful according to the rules lined out here

Parameters:

`[in]`	pPart	generic pointer to non-modifiable physics or signal object contributing to the MET object
`[in]`	constList	reference to non-modifiable list of (base type) pointers to signals associated with the given physics object

bool xAOD::MissingETComposition::insert	(	MissingETAssociationMap *	pMap,
		const Jet *	pJet,
		const IParticle *	pPart,
		const std::vector< const IParticle * > &	constlist
	)			`[static]`

Insert contributing object to jet referenced by pointer, with constVecs for track and calo constituents.

Returns:: true if insertion successful according to the rules lined out here

Parameters:

`[in]`	pJet	non-modifiable pointer to the reference jet
`[in]`	pPart	generic pointer to non-modifiable physics or signal object contributing to the MET object
`[in]`	constList	reference to non-modifiable list of (base type) pointers to signals associated with the given physics object

bool xAOD::MissingETComposition::insert	(	MissingETAssociationMap *	pMap,
		size_t	jetIndex,
		const IParticle *	pPart,
		const std::vector< const IParticle * > &	constlist
	)			`[static]`

Insert contributing object to jet referenced by index, with constVecs for track and calo constituents.

Returns:: true if insertion successful according to the rules lined out here

Parameters:

`[in]`	pJet	non-modifiable pointer to the reference jet
`[in]`	pPart	generic pointer to non-modifiable physics or signal object contributing to the MET object
`[in]`	constList	reference to non-modifiable list of (base type) pointers to signals associated with the given physics object

bool xAOD::MissingETComposition::insert	(	MissingETComponentMap *	pMap,
		const MissingET *	pMET,
		const IParticle *	pPart,
		const MissingETBase::Types::object_vector_t &	signalList,
		double	wpx,
		double	wpy,
		double	wet,
		MissingETBase::UsageHandler::Policy	p = `MissingETBase::UsageHandler::OnlyCluster`
	)			`[static]`

Insert MET object and contributing object by pointers, with list of signals and individual weight components.

insert(MissingETComponentMap*,const MissingET*,const IParticle*,double,double,double)

Parameters:

`[in]`	signalList	reference to non-modifiable list of (base type) pointers to signals associated with the given physics or signal object
`[in]`	p	signal type indicator (optional, default is MissingETBase:UsageHandler::OnlyCluster)

bool xAOD::MissingETComposition::insert	(	MissingETComponentMap *	pMap,
		const MissingET *	pMET,
		const IParticle *	pPart,
		double	wpx,
		double	wpy,
		double	wet
	)			`[static]`

Insert MET object and contributing object by pointers, with individual weights.

Returns:: true if insertion successful according to the rules lined out here

Parameters:

`[in]`	pMET	pointer to non-modifiable MET object
`[in]`	pPart	generic pointer to non-modifiable physics or signal object contributing to the MET object
`[in]`	wpx	kinematic weight $w_{x}$
`[in]`	wpy	kinematic weight $w_{y}$
`[in]`	wet	kinematic weight $w_{\rm T}$

bool xAOD::MissingETComposition::insert	(	MissingETComponentMap *	pMap,
		const MissingET *	pMET,
		const IParticle *	pPart,
		const MissingETBase::Types::object_vector_t &	signalList,
		MissingETBase::Types::weight_t	weight = `MissingETBase::Types::weight_t()`,
		MissingETBase::UsageHandler::Policy	p = `MissingETBase::UsageHandler::OnlyCluster`
	)			`[static]`

Insert MET object and contributing object by pointers, with list of signals and optional kinematic weight object.

insert(MissingETComponentMap*,const MissingET*,const IParticle*,MissingETBase::Types::weight_t)

Parameters:

`[in]`	signalList	reference to non-modifiable list of (base type) pointers to signals associated with the given physics or signal object
`[in]`	p	signal type indicator (optional, default is MissingETBase:UsageHandler::OnlyCluster)

bool xAOD::MissingETComposition::insert	(	MissingETComponentMap *	pMap,
		const MissingET *	pMET,
		const IParticle *	pPart,
		MissingETBase::Types::weight_t	weight = `MissingETBase::Types::weight_t()`
	)			`[static]`

Insert contributing signal or physics object by pointer, with optional kinematic weight object.

Returns:: true if insertion successful according to the rules lined out here

Parameters:

`[in]`	pMET	pointer to non-modifiable MET object
`[in]`	pPart	generic pointer to non-modifiable physics or signal object contributing to the MET object
`[in]`	weight	kinematic weights of the contribution (optional, for default see MissingETComponent::Weight::Weight() constructor)

bool xAOD::MissingETComposition::insertMisc	(	MissingETAssociationMap *	pMap,
		const IParticle *	pPart,
		const std::vector< const IParticle * > &	constlist
	)			`[static]`

Insert contributing object into miscellaneous association.

Returns:: true if insertion successful according to the rules lined out here

Parameters:

`[in]`	pPart	generic pointer to non-modifiable physics or signal object contributing to the MET object
`[in]`	constList	reference to non-modifiable list of (base type) pointers to signals associated with the given physics object

bool xAOD::MissingETComposition::updateLinks ( MissingETComponentMap * pMap ) [static]

Update all ElementLinks in all contributions.

This function triggers an update of all ElementLinks stored in the map entries. This may be necessary in case a MissingETComponent object has been filled with POD MET, particle, and/or signal objects, thus rendering the corresponding ElementLink incomplete. If the linked to objects are stored in a collection later, this function makes sure that all ElementLinks are updated with the collection pointer.

Warning:: Usually MET terms are reconstructed from signal or physics objects stored in a collection. In this case this function does not need to be used at all, as all ElemenntLinks to contributing objects are complete. On the other hand, the MissingET in the contribution is usually still a POD when the composition map entry for the corresponding MET term is generated, and the ElementLink to it requires an update later, when the MissingET object is stored in a MissingEETContainer . In this case MissingETComposition::updateMETLinks(MissingETComponentMap*) should be used after the MET object is inserted in its container, as it is much faster (only scans the small number of MissingETComponent objects in the map).

Returns:: true if all links in all MET contributions in the composition map are updated correctly. In case of an unsuccessful update attempt, or an invalid pointer to the MissingETComponentMap object (NULL pointer), false is returned.

Parameters:

[in] pMap pointer referencing a modifiable MET composition map.

Note:: This method involves a scan of all MissingETComponent objects stored in the map, and a scan of the contributing object list in these MET contributions. This can be costly in terms off CPU usage.

bool xAOD::MissingETComposition::updateMETLinks ( MissingETComponentMap * pMap ) [static]

Update all ElementLinks to MET objects only in all contributions.

This function triggers an update of all ElementLinks stored in the map entries. This may be necessary in case a MissingETComponent object has been filled with POD MissingET , thus rendering the corresponding ElementLink incomplete. If the linked to MET objects are stored in a collection later, this function makes sure that the ElementLinks are updated with the collection pointer.

Returns:: true if all links to MissingET objects in all MET contributions in the composition map are updated correctly. In case of an unsuccessful update attempt, or an invalid pointer to the MissingETComponentMap object (NULL pointer), false is returned.

Parameters:

[in] pMap pointer referencing a modifiable MET composition map.

Note:: This method involves a scan of all MissingETComponent objects stored in the map.

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

/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODMissingET/xAODMissingET/MissingETComposition.h
/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODMissingET/Root/MissingETComposition.cxx

xAOD::MissingETComposition Struct Reference

Static Public Member Functions

Detailed Description

Member Function Documentation