xAOD::MissingETComposition Struct Reference

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

#include <MissingETComposition.h>

Collaboration diagram for xAOD::MissingETComposition:

Static Public Member Functions
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.
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 MissingETAssociationHelper &helper, const IParticle *obj)
static bool	selectIfNoOverlaps (MissingETAssociationHelper &helper, 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)
template<int OBJTYPE>
static bool	fillMissingET (const MissingETComponentMap *pMap, MissingET *pMET, MissingETBase::Types::bitmask_t=MissingETBase::Status::clearedStatus())
	Fill a given MissingET object.
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.

Definition at line 21 of file Event/xAOD/xAODMissingET/xAODMissingET/MissingETComposition.h.

Member Function Documentation

add() [1/3]

bool 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.

Definition at line 204 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  {
    // input check
    if ( pMap == nullptr || pJet == nullptr ) 
      { printf("MissingETComposition::add - ERROR - possible invalid pointer values: MissingETAssociationMap* = %p, Jet* = %p\n",(void*)pMap,(void*)pJet); return false; }
    // check if jet already in map
    if ( pMap->find(pJet) != pMap->end() ) 
      { printf("MissingETComposition::add - WARNING - jet with index %zu already in map, not added again\n",pJet->index()); return false; }
    // insert object
    // size_t nextIdx = pMap->size();
    std::vector<ElementLink<IParticleContainer> > jetconst = pJet->constituentLinks();
    MissingETBase::Types::constvec_t trkvec;
    if(!jettracks.empty()) {
      const IParticleContainer* pTrkCont = static_cast<const IParticleContainer*>(jettracks.front()->container());
      for(const auto& trk : jettracks) {  
        ElementLink<IParticleContainer> link(*pTrkCont,trk->index());
        jetconst.push_back(link);
        trkvec += *trk;
      }
    }
    return add(pMap,pJet,jetconst,trkvec);
  }

add() [2/3]

bool 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.

Definition at line 186 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  {
    // input check
    if ( pMap == nullptr || pJet == nullptr ) 
      { printf("MissingETComposition::add - ERROR - possible invalid pointer values: MissingETAssociationMap* = %p, Jet* = %p\n",(void*)pMap,(void*)pJet); return false; }
    // check if jet already in map
    if ( pMap->find(pJet) != pMap->end() ) 
      { printf("MissingETComposition::add - WARNING - jet with index %zu already in map, not added again\n",pJet->index()); return false; }
    // insert object
    size_t nextIdx = pMap->size();
    pMap->push_back(new MissingETAssociation(pJet));
    pMap->setJetConstituents(jetconst,nextIdx);
    // printf("Jet track vector: px %f, py %f\n",trkvec.cpx(),trkvec.cpy());
    pMap->back()->setJetTrkVec(trkvec);
    return pMap->back() != nullptr;
  }

add() [3/3]

bool 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())

Definition at line 29 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  {
    // input check
    if ( pMap == nullptr || pMET == nullptr ) 
      { printf("MissingETComposition::add - ERROR - possible invalid pointer values: MissingETComponentMap* = %p, MissingET* = %p\n",(void*)pMap,(void*)pMET); return false; }
    // check if MET object already in map
    if ( pMap->find(pMET) != pMap->end() ) 
      { printf("MissingETComposition::add - WARNING - MissingET object \042%s\042 already in map, not added again\n",pMET->name().c_str()); return false; }
    // insert object
    pMap->push_back(new MissingETComponent(pMET,sw));
    return pMap->back() != nullptr;
  }

addMiscAssociation()

bool 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.

Definition at line 227 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  {
    // input check
    if ( pMap == nullptr ) 
      { printf("MissingETComposition::addMiscAssociation - ERROR - possible invalid pointer values: MissingETAssociationMap* = %p\n",(void*)pMap); return false; }
    // insert object
    pMap->push_back(new MissingETAssociation((const Jet*)nullptr,true));
    return pMap->back() != nullptr;
  }

begin() [1/2]

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).

begin() [2/2]

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).

end() [1/2]

MissingETComponentMap::const_iterator xAOD::MissingETComposition::end ( const MissingETComponentMap * pMap )

static

end() [2/2]

MissingETComponentMap::iterator xAOD::MissingETComposition::end ( MissingETComponentMap * pMap )

static

fillMissingET()

template<int OBJTYPE>

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

inlinestatic

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())

Definition at line 200 of file Event/xAOD/xAODMissingET/xAODMissingET/MissingETComposition.h.

    {
      if ( pMap == 0 || pMap->empty() ) return false;
      //
      double sumet(pMET->sumet());
      MissingETComponentMap::const_iterator fComp(pMap->begin());
      MissingETComponentMap::const_iterator lComp(pMap->end());
      for ( ; fComp != lComp; ++fComp ) 
    { 
      const MissingETComponent* pCont = *fComp;
      if ( pCont != 0 )
        {
          // get objects from contribution
          MissingETBase::Types::weight_vector_t kinePars;
          MissingETBase::Types::object_vector_t objs = pCont->objects(kinePars);
          for ( size_t iObj(0); iObj<objs.size(); ++iObj )
        { 
          if ( objs[iObj]->type() == OBJTYPE ) 
            { // this is really stupid!!!!
              pMET->add(objs.at(iObj)->p4().Px()*kinePars.at(iObj).wpx(),
                objs.at(iObj)->p4().Py()*kinePars.at(iObj).wpy(),
                objs.at(iObj)->pt()*kinePars.at(iObj).wet());
            } // requested type
        } // loop on contributing objects
        } // contribution valid
    } // loop on all contributions
      return pMET->sumet() != sumet;
    } // fillMissingET

find() [1/12]

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.

find() [2/12]

MissingETAssociationMap::const_iterator 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).

Definition at line 333 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return pMap != nullptr ? pMap->find(pJet) : MissingETAssociationMap::const_iterator(); }

find() [3/12]

MissingETAssociationMap::const_iterator 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.

Definition at line 100 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  {
    if ( pMap == nullptr ) { return MissingETComponentMap::const_iterator(); }
    // linear search - FIXME: method find(const IParticle*) in MissingETComponentMap ??
    MissingETComponentMap::const_iterator fCont(pMap->begin()); 
    MissingETComponentMap::const_iterator lCont(pMap->end());
    bool found(false);
    while ( fCont != lCont && !found ) { found = (*fCont)->findIndex(pPart) != MissingETBase::Numerical::invalidIndex(); if ( !found ) { ++fCont; } }
    return fCont;
  }

find() [4/12]

MissingETComponentMap::const_iterator 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).

Definition at line 82 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return pMap != nullptr ? pMap->find(pMET) : MissingETComponentMap::const_iterator(); }

find() [5/12]

MissingETComponentMap::const_iterator MissingETComposition::find ( const MissingETComponentMap * pMap, const std::string & metName )

static

Definition at line 88 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return pMap !=nullptr ? pMap->find(metName) : MissingETComponentMap::const_iterator(); }

find() [6/12]

MissingETComponentMap::const_iterator MissingETComposition::find ( const MissingETComponentMap * pMap, MissingETBase::Types::bitmask_t src )

static

Definition at line 94 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return pMap !=nullptr ? pMap->find(src) : MissingETComponentMap::const_iterator(); }

find() [7/12]

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.

find() [8/12]

MissingETAssociationMap::iterator MissingETComposition::find ( MissingETAssociationMap * pMap, const Jet * pJet )

static

Definition at line 336 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return pMap != nullptr ? pMap->find(pJet) : MissingETAssociationMap::iterator(); }

find() [9/12]

MissingETAssociationMap::iterator 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.

Definition at line 111 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  {
    if ( pMap == nullptr ) { return MissingETComponentMap::iterator(); }
    // linear search - FIXME: method find(const IParticle*) in MissingETComponentMap ??
    MissingETComponentMap::iterator fCont(pMap->begin()); 
    MissingETComponentMap::iterator lCont(pMap->end());
    bool found(false);
    while ( fCont != lCont && !found ) { found = (*fCont)->findIndex(pPart) != MissingETBase::Numerical::invalidIndex(); if ( !found ) { ++fCont; } }
    return fCont;
  }

find() [10/12]

MissingETComponentMap::iterator MissingETComposition::find ( MissingETComponentMap * pMap, const MissingET * pmetObj )

static

Definition at line 85 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return pMap != nullptr ? pMap->find(pMET) : MissingETComponentMap::iterator(); }

find() [11/12]

MissingETComponentMap::iterator MissingETComposition::find ( MissingETComponentMap * pMap, const std::string & metName )

static

Definition at line 91 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return pMap !=nullptr ? pMap->find(metName) : MissingETComponentMap::iterator(); }

find() [12/12]

MissingETComponentMap::iterator MissingETComposition::find ( MissingETComponentMap * pMap, MissingETBase::Types::bitmask_t src )

static

Definition at line 97 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return pMap !=nullptr ? pMap->find(src) : MissingETComponentMap::iterator(); }

findIndex() [1/3]

size_t xAOD::MissingETComposition::findIndex ( const MissingETComponentMap * pMap, const MissingET * pmetObj )

static

findIndex() [2/3]

size_t xAOD::MissingETComposition::findIndex ( const MissingETComponentMap * pMap, const std::string & metName )

static

findIndex() [3/3]

size_t xAOD::MissingETComposition::findIndex ( const MissingETComponentMap * pMap, MissingETBase::Types::bitmask_t src )

static

getAssociation() [1/2]

const MissingETAssociation * MissingETComposition::getAssociation ( const MissingETAssociationMap * pMap, const Jet * pJet )

static

Definition at line 415 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { MissingETAssociationMap::const_iterator fAssoc(find(pMap,pJet)); return fAssoc != pMap->end() ? *fAssoc : (const MissingETAssociation*)nullptr; }

getAssociation() [2/2]

MissingETAssociation * MissingETComposition::getAssociation ( MissingETAssociationMap * pMap, const Jet * pJet )

static

Definition at line 418 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { MissingETAssociationMap::iterator fAssoc(find(pMap,pJet)); return fAssoc != pMap->end() ? *fAssoc : (MissingETAssociation*)nullptr; }

getAssociations() [1/2]

std::vector< const MissingETAssociation * > 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.

Definition at line 391 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { 
    std::vector<const MissingETAssociation*> assocs;
    if ( pMap == nullptr ) { return assocs; }
    else {
      for (const auto fAssoc : *pMap) {
    if (fAssoc->findIndex(pPart) != MissingETBase::Numerical::invalidIndex()) assocs.push_back(fAssoc);
      }
    }
    return assocs;
  } 

getAssociations() [2/2]

std::vector< MissingETAssociation * > 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.

Definition at line 403 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { 
    std::vector<MissingETAssociation*> assocs;
    if ( pMap == nullptr ) { return assocs; }
    else {
      for (const auto fAssoc : *pMap) {
    if (fAssoc->findIndex(pPart) != MissingETBase::Numerical::invalidIndex()) assocs.push_back(fAssoc);
      }
    }
    return assocs;
  } 

getComponent() [1/8]

const MissingETComponent * 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.

Definition at line 122 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { 
    if ( pMap == nullptr ) { return (const MissingETComponent*)nullptr; }
    else { MissingETComponentMap::const_iterator fCont(find(pMap,pPart)); return fCont != pMap->end() ? *fCont : (const MissingETComponent*)nullptr; }
  } 

getComponent() [2/8]

const MissingETComponent * MissingETComposition::getComponent ( const MissingETComponentMap * pMap, const MissingET * pmetObj )

static

Definition at line 134 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { MissingETComponentMap::const_iterator fCont(find(pMap,pMET)); return fCont != pMap->end() ? *fCont : (const MissingETComponent*)nullptr; }

getComponent() [3/8]

const MissingETComponent * MissingETComposition::getComponent ( const MissingETComponentMap * pMap, const std::string & metName )

static

Definition at line 140 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { MissingETComponentMap::const_iterator fCont(find(pMap,metName)); return fCont != pMap->end() ? *fCont : (const MissingETComponent*)nullptr; }

getComponent() [4/8]

const MissingETComponent * MissingETComposition::getComponent ( const MissingETComponentMap * pMap, MissingETBase::Types::bitmask_t src )

static

Definition at line 146 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { MissingETComponentMap::const_iterator fCont(find(pMap,sw)); return fCont != pMap->end() ? *fCont : (const MissingETComponent*)nullptr; }

getComponent() [5/8]

MissingETComponent * 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.

Definition at line 128 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { 
    if ( pMap == nullptr ) { return (MissingETComponent*)nullptr; }
    else { MissingETComponentMap::iterator fCont(find(pMap,pPart)); return fCont != pMap->end() ? *fCont : (MissingETComponent*)nullptr; }
  } 

getComponent() [6/8]

MissingETComponent * MissingETComposition::getComponent ( MissingETComponentMap * pMap, const MissingET * pmetObj )

static

Definition at line 137 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { MissingETComponentMap::iterator fCont(find(pMap,pMET)); return fCont != pMap->end() ? *fCont : (MissingETComponent*)nullptr; }

getComponent() [7/8]

MissingETComponent * MissingETComposition::getComponent ( MissingETComponentMap * pMap, const std::string & metName )

static

Definition at line 143 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { MissingETComponentMap::iterator fCont(find(pMap,metName)); return fCont != pMap->end() ? *fCont : (MissingETComponent*)nullptr; }

getComponent() [8/8]

MissingETComponent * MissingETComposition::getComponent ( MissingETComponentMap * pMap, MissingETBase::Types::bitmask_t src )

static

Definition at line 149 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { MissingETComponentMap::iterator fCont(find(pMap,sw)); return fCont != pMap->end() ? *fCont : (MissingETComponent*)nullptr; }

getConstVec()

MissingETBase::Types::constvec_t MissingETComposition::getConstVec ( const MissingETAssociationMap * pMap, const IParticle * pPart, MissingETBase::UsageHandler::Policy p )

static

Definition at line 361 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { 
    MissingETBase::Types::constvec_t totalvec;
    std::vector<const MissingETAssociation*> assocs = getAssociations(pMap,pPart);
    for (size_t i = 0; i < assocs.size(); i++) {
      if (p==MissingETBase::UsageHandler::OnlyTrack) {
    totalvec += assocs[i]->trkVec(pPart);
      } else {
    totalvec += assocs[i]->calVec(pPart);
      }
    }
    return totalvec;
  } 

getMissingET() [1/4]

const MissingET * MissingETComposition::getMissingET ( const MissingETComponentMap * pMap, const IParticle * pPart )

static

Definition at line 170 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return getMissingET(find(pMap,pPart)); }

getMissingET() [2/4]

const MissingET * MissingETComposition::getMissingET ( const MissingETComponentMap * pMap, const std::string & name )

static

Definition at line 176 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return getMissingET(find(pMap,name)); }

getMissingET() [3/4]

const MissingET * MissingETComposition::getMissingET ( const MissingETComponentMap * pMap, MissingETBase::Types::bitmask_t sw )

static

Definition at line 179 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return getMissingET(find(pMap,sw)); }

getMissingET() [4/4]

const MissingET * MissingETComposition::getMissingET ( MissingETComponentMap::const_iterator fCont )

static

Definition at line 173 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return *fCont != nullptr  ? (*fCont)->metObject() : (const MissingET*)nullptr; }

getRefJet() [1/2]

const Jet * MissingETComposition::getRefJet ( const MissingETAssociationMap * pMap, const IParticle * pPart )

static

Definition at line 425 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  {
    MissingETAssociationMap::const_iterator fAssoc = find(pMap,pPart);
    return fAssoc==pMap->end() ? nullptr : getRefJet(fAssoc);
  }

getRefJet() [2/2]

const Jet * MissingETComposition::getRefJet ( MissingETAssociationMap::const_iterator fCont )

static

Definition at line 431 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return *fAssoc != nullptr  ? (*fAssoc)->refJet() : (const Jet*) nullptr; }

getStatusWord() [1/2]

MissingETBase::Types::bitmask_t MissingETComposition::getStatusWord ( const MissingETComponentMap * pMap, const MissingET * pmetObj )

static

Definition at line 163 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { MissingETComponentMap::const_iterator fCont(find(pMap,pmetObj)); return fCont == pMap->end() ? MissingETBase::Status::clearedStatus() : (*fCont)->statusWord(); }

getStatusWord() [2/2]

MissingETBase::Types::bitmask_t MissingETComposition::getStatusWord ( MissingETComponentMap::const_iterator fCont )

static

Definition at line 166 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return *fCont != nullptr ? (*fCont)->statusWord() : MissingETBase::Status::clearedStatus(); }

getWeight() [1/2]

MissingETBase::Types::weight_t MissingETComposition::getWeight ( const MissingETComponentMap * pMap, const IParticle * pPart )

static

Definition at line 155 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { MissingETComponentMap::const_iterator fCont(find(pMap,pPart)); return fCont == pMap->end() ? MissingETBase::Types::weight_t(0.,0.,0.) : (*fCont)->weight(pPart); }

getWeight() [2/2]

MissingETBase::Types::weight_t MissingETComposition::getWeight ( MissingETComponentMap::const_iterator fCont, const IParticle * pPart )

static

Definition at line 159 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return *fCont != nullptr ? (*fCont)->weight(pPart) : MissingETBase::Types::weight_t(0.,0.,0.); }

insert() [1/7]

bool 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

Definition at line 266 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { 
    // input check
    if ( pMap == nullptr )
      { printf("MissingETComposition::insert - ERROR - possible invalid pointer values: MissingETAssociationMap* = %p\n",(void*)pMap); return false; }
    
    // loop over constituents and try to identify an appropriate association
    // FIXME: check in case more than one appropriate index found?
    std::map<size_t,std::vector<const IParticle*> > constMap;
    for(const auto& signal : constlist) {
      size_t jetIndex = pMap->findIndexByJetConst(signal);
      // printf("Constituent type %i, jetIndex %lu\n",signal->type(),jetIndex);
      constMap[jetIndex].push_back(signal);
    }
    std::map<size_t,std::vector<const IParticle*> >::iterator jetIter;
    for(auto& jetIter : constMap) {
      if(jetIter.first!=MissingETBase::Numerical::invalidIndex()) {
        insert(pMap,jetIter.first,pPart,jetIter.second);
    // printf("Associated object (type %d, pt %f) with jet %lu\n",pPart->type(),pPart->pt(),jetIter.first);
        (*pMap)[jetIter.first]->addOverrideMom(pOverride);
      } else {
    insertMisc(pMap,pPart,jetIter.second);
        pMap->getMiscAssociation()->addOverrideMom(pOverride);
      }
    }
    if (constMap.empty()) insertMisc(pMap,pPart,std::vector<const IParticle*>());
    return true;
  }

insert() [2/7]

bool 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

Definition at line 253 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { 
    // input check
    if ( pMap == nullptr || pJet == nullptr )
      { printf("MissingETComposition::insert - ERROR - possible invalid pointer values: MissingETAssociationMap* = %p, Jet* = %p\n",(void*)pMap,(void*)pJet); return false; }
    // check if jet already in map
    size_t jetIndex(pMap->findIndex(pJet));
    if ( jetIndex==MissingETBase::Numerical::invalidIndex())
      { printf("MissingETComposition::insert - WARNING - jet with pointer %p not in map, could not add\n",(void*)pJet); return false; }
 
    return insert(pMap,jetIndex,pPart,constlist);
  }

insert() [3/7]

bool 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

Definition at line 237 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { 
    // input check
    if ( pMap == nullptr )
      { printf("MissingETComposition::insert - ERROR - possible invalid pointer value: MissingETAssociationMap* = %p\n",(void*)pMap); return false; }
    // check if MET object already in map
 
    // printf("MissingETComposition::insert - INFO - associated to jet %lu\n",jetIndex);
 
    if ( jetIndex==MissingETBase::Numerical::invalidIndex() || jetIndex>=pMap->size())
      { printf("MissingETComposition::insert - WARNING - no MissingETAssociation matching this jet, could not add\n"); return false; }
 
    (*pMap)[jetIndex]->addObject(pPart,constlist);
    return true;
  }

insert() [4/7]

bool 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.

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} \)
[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)

Definition at line 63 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  {
    bool flag(insert(pMap,pMET,pPart,wpx,wpy,wet)); 
    if ( flag && !signalList.empty() ) { flag = pMap->addObjects(pMET,pPart,signalList,p); }
    return flag;
  }

insert() [5/7]

bool 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.

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)
[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)

Definition at line 59 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return insert(pMap,pMET,pPart,signalList,weight.wpx(),weight.wpy(),weight.wet(),p); }

insert() [6/7]

bool 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} \)

Definition at line 45 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { 
    // input check
    if ( pMap == nullptr || pMET == nullptr )
      { printf("MissingETComposition::insert - ERROR - possible invalid pointer values: MissingETComponentMap* = %p, MissingET* = %p\n",(void*)pMap,(void*)pMET); return false; }
    // check if MET object already in map
    MissingETComponentMap::iterator fMap(pMap->find(pMET));
    if (  fMap == pMap->end() ) 
      { printf("MissingETComposition::insert - ERROR - referenced MissingET object \042%%%s\042 not yet in map, add first!\n",pMET->name().c_str()); return false; }
 
    (*fMap)->addObject(pPart,wpx,wpy,wet);
    return true;
  }

insert() [7/7]

bool 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)

Definition at line 42 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { return insert(pMap,pMET,pPart,weight.wpx(),weight.wpy(),weight.wet()); }

insertMisc()

bool 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

Definition at line 312 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

  { 
    // input check
    if ( pMap == nullptr )
      { printf("MissingETComposition::insertMisc - ERROR - possible invalid pointer values: MissingETAssociationMap* = %p\n",(void*)pMap); return false; }
    
    size_t jetIndex(MissingETBase::Numerical::invalidIndex());
    // loop over constituents and make sure these don't belong to some other association
    // printf("Associated object (type %d, pt %f) with no jet\n",pPart->type(),pPart->pt());
    for(const auto& signal : constlist) {
      // printf("MissingETComposition::insertMisc - INFO - constituent pt %f\n", signal->pt());
      jetIndex = pMap->findIndexByJetConst(signal);
      if(jetIndex!=MissingETBase::Numerical::invalidIndex()) {
    printf("MissingETComposition::insertMisc - ERROR - object %p with constituent %p is associated to jet %zu, will not place in misc association\n",(void*)pPart,(void*)signal,jetIndex); return false;
      }
    }
    pMap->getMiscAssociation()->addObject(pPart,constlist);
 
    return true;
  }

objSelected()

bool MissingETComposition::objSelected ( const MissingETAssociationHelper & helper, const IParticle * obj )

static

Definition at line 375 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

                                                                                                      {
    std::vector<const MissingETAssociation*> assocs = getAssociations(helper.map(),obj);
    for(size_t i = 0; i < assocs.size(); i++) if(helper.objSelected(assocs[i],obj)) return true;
    return false;
  }

selectIfNoOverlaps()

bool MissingETComposition::selectIfNoOverlaps ( MissingETAssociationHelper & helper, const IParticle * obj, MissingETBase::UsageHandler::Policy p )

static

Definition at line 382 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

                                                                                                                                         {
    std::vector<const MissingETAssociation*> assocs = getAssociations(helper.map(),obj);
    bool overlaps(false);
    for(size_t i = 0; i < assocs.size(); i++) overlaps |= assocs[i]->hasOverlaps(helper,obj,p);
    if (overlaps) return false; 
    for(size_t i = 0; i < assocs.size(); i++) helper.setObjSelectionFlag(assocs[i],obj,true);
    return true;
  }

setJetConstSum()

bool MissingETComposition::setJetConstSum ( MissingETAssociationMap * metMap, const Jet * jet, const std::vector< const IParticle * > & altConsts, std::map< const IParticle *, MissingETBase::Types::constvec_t > pOverride )

static

Definition at line 296 of file Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx.

                                                                                     {
    std::vector<ElementLink<IParticleContainer> > jetconst;
    if(!altConsts.empty()) {
      for(const auto& alt : altConsts) {  
        const IParticleContainer* pCont = static_cast<const IParticleContainer*>(alt->container());
        ElementLink<IParticleContainer> link(*pCont,alt->index());
        jetconst.push_back(link);
      }
    }
    metMap->setJetConstituents(jetconst,jet);
    if (!altConsts.empty()) insert(metMap,jet,altConsts,std::move(pOverride));
    else insert(metMap,jet,jet,altConsts);
    return true;
  }

---

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

• Event/xAOD/xAODMissingET/xAODMissingET/MissingETComposition.h
• Event/xAOD/xAODMissingET/Root/MissingETComposition.cxx