xAOD::MissingETComposition Struct Reference

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

#include <MissingETComposition.h>

List of all members.

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 MissingETComponentgetComponent (const MissingETComponentMap *pMap, const IParticle *pPart)
 Access non-modifiable contribution object.
static const MissingETComponentgetComponent (const MissingETComponentMap *pMap, const MissingET *pmetObj)
static const MissingETComponentgetComponent (const MissingETComponentMap *pMap, const std::string &metName)
static const MissingETComponentgetComponent (const MissingETComponentMap *pMap, MissingETBase::Types::bitmask_t src)
static MissingETComponentgetComponent (MissingETComponentMap *pMap, const IParticle *pPart)
 Access non-modifiable contribution object.
static MissingETComponentgetComponent (MissingETComponentMap *pMap, const MissingET *pmetObj)
static MissingETComponentgetComponent (MissingETComponentMap *pMap, const std::string &metName)
static MissingETComponentgetComponent (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 MissingETAssociationgetAssociation (const MissingETAssociationMap *pMap, const Jet *pJet)
static std::vector
< MissingETAssociation * > 
getAssociations (MissingETAssociationMap *pMap, const IParticle *pPart)
 Access non-modifiable contribution object.
static MissingETAssociationgetAssociation (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 MissingETgetMissingET (const MissingETComponentMap *pMap, const IParticle *pPart)
static const MissingETgetMissingET (MissingETComponentMap::const_iterator fCont)
static const MissingETgetMissingET (const MissingETComponentMap *pMap, const std::string &name)
static const MissingETgetMissingET (const MissingETComponentMap *pMap, MissingETBase::Types::bitmask_t sw)
static const JetgetRefJet (const MissingETAssociationMap *pMap, const IParticle *pPart)
static const JetgetRefJet (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:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 1 Dec 2017 for RootCore Packages by  doxygen 1.6.1