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

#include <MissingETAssociation_v1.h>

Inheritance diagram for xAOD::MissingETAssociation_v1:

Collaboration diagram for xAOD::MissingETAssociation_v1:

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

Public Member Functions

MissingETAssociation_v1 (bool createStore=false)

Default constructor.

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

Construct with a link to a Jet object.

MissingETAssociation_v1 (const MissingETAssociation_v1 &assocDescr)

Copy constructor.

MissingETAssociation_v1 & operator= (const MissingETAssociation_v1 &assocDescr)

virtual ~MissingETAssociation_v1 ()

Assignment operator.

size_t findCalIndex (MissingETBase::Types::bitmask_t mask) const

size_t findTrkIndex (MissingETBase::Types::bitmask_t mask) const

Set reference jet

Base class destructor

bool setRefJet (const Jet *pJet)

Set reference jet by object pointer reference.

bool setRefJet (const JetContainer *pJetCont, size_t pJetIdx)

Set reference jet by container pointer and index reference.

Adding data to the MET association description

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

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

Conventional and dedicated getter and setters

const std::vector< float > & calpx () const

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

float calpx (const IParticle *pPart) const

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

float calpx (size_t keyIdx) const

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

bool setCalPx (const std::vector< float > &calpxvec)

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

bool setCalPx (size_t keyIdx, float calpx)

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

const std::vector< float > & calpy () const

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

float calpy (size_t keyIdx) const

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

bool setCalPy (const std::vector< float > &calpyvec)

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

bool setCalPy (size_t keyIdx, float calpy)

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

const std::vector< float > & calpz () const

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

float calpz (size_t keyIdx) const

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

bool setCalPz (const std::vector< float > &calpzvec)

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

bool setCalPz (size_t keyIdx, float calpz)

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

const std::vector< float > & cale () const

Get the vector of \( E \).

float cale (size_t keyIdx) const

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

bool setCalE (const std::vector< float > &calevec)

Set the vector of \( E \).

bool setCalE (size_t keyIdx, float cale)

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

const std::vector< float > & calsumpt () const

Get the vector of sumpt.

float calsumpt (size_t keyIdx) const

Get the sumpt for a given object referenced by index.

bool setCalSumpt (const std::vector< float > &calsumptvec)

Set the vector of sumpt.

bool setCalSumpt (size_t keyIdx, float calsumpt)

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

const std::vector< MissingETBase::Types::bitmask_t > & calkey () const

Get the vector of cal keys.

MissingETBase::Types::bitmask_t calkey (size_t keyIdx) const

Get the key for a given entry referenced by index.

bool setCalKey (const std::vector< MissingETBase::Types::bitmask_t > &calkeyvec)

Set the vector of keys.

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

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

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

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

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

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

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

Add a key/vector pair for calo contributions.

bool clearCalVecs ()

Reset the calo constituent vectors and keys.

const std::vector< float > & trkpx () const

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

float trkpx (size_t keyIdx) const

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

bool setTrkPx (const std::vector< float > &trkpxvec)

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

bool setTrkPx (size_t keyIdx, float trkpx)

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

const std::vector< float > & trkpy () const

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

float trkpy (size_t keyIdx) const

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

bool setTrkPy (const std::vector< float > &trkpyvec)

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

bool setTrkPy (size_t keyIdx, float trkpy)

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

const std::vector< float > & trkpz () const

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

float trkpz (size_t keyIdx) const

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

bool setTrkPz (const std::vector< float > &trkpzvec)

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

bool setTrkPz (size_t keyIdx, float trkpz)

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

const std::vector< float > & trke () const

Get the vector of \( E \).

float trke (size_t keyIdx) const

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

bool setTrkE (const std::vector< float > &trkevec)

Set the vector of \( E \).

bool setTrkE (size_t keyIdx, float trke)

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

const std::vector< float > & trksumpt () const

Get the vector of \( E \).

float trksumpt (size_t keyIdx) const

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

bool setTrkSumpt (const std::vector< float > &trksumptvec)

Set the vector of \( E \).

bool setTrkSumpt (size_t keyIdx, float trksumpt)

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

const std::vector< MissingETBase::Types::bitmask_t > & trkkey () const

Get the vector of trk keys.

MissingETBase::Types::bitmask_t trkkey (size_t keyIdx) const

Get the key for a given entry referenced by index.

bool setTrkKey (const std::vector< MissingETBase::Types::bitmask_t > &trkkeyvec)

Set the vector of keys.

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

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

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

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

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

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

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

Add a key/vector pair for calo contributions.

bool clearTrkVecs ()

Reset the track constituent vectors and keys.

float jettrkpx () const

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

float jettrkpy () const

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

float jettrkpz () const

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

float jettrke () const

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

float jettrksumpt () const

Get the sumpt for a given object referenced by index.

void setJetTrkPx (float px)

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

void setJetTrkPy (float py)

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

void setJetTrkPz (float pz)

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

void setJetTrkE (float e)

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

void setJetTrkSumpt (float sumpt)

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

void setJetTrkVec (const ConstVec &cvec=ConstVec())

Set the track constituent vector for the reference jet.

void setJetTrkVec (float px, float py, float pz, float ce, float sumpt)

Set the track constituent vector for the reference jet.

const MissingETBase::Types::jetlink_t & jetLink () const

Get the link to the reference jet.

bool setJetLink (const MissingETBase::Types::jetlink_t &jetLnk)

Set the link to the reference jet.

const MissingETBase::Types::objlink_vector_t & objectLinks () const

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

bool setObjectLinks (const MissingETBase::Types::objlink_vector_t &objLnks)

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

const std::vector< std::vector< size_t > > & overlapIndices () const

Get the list of object overlapIndices.

std::vector< size_t > overlapIndices (const IParticle *pPart) const

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

std::vector< size_t > overlapIndices (size_t objIdx) const

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

const std::vector< std::vector< unsigned char > > & overlapTypes () const

Get the list of object overlapTypes.

std::vector< unsigned char > overlapTypes (const IParticle *pPart) const

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

std::vector< unsigned char > overlapTypes (size_t objIdx) const

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

void clearOverlaps ()

Clear the vectors of overlap indices.

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

Set the vector of overlap indices and types.

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

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

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

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

void setOverrideMom (const std::map< const IParticle *, ConstVec > &pOverride)

Set override momenta.

std::map< const IParticle *, ConstVec > overrideMom ()

Get override momenta.

void addOverrideMom (std::map< const IParticle *, ConstVec > &pOverride)

Extend override momentum map.

Specific methods for manipulating the association description data

bool removeContrib (const IParticle *pPart)

Remove a contribution referenced by an object pointer.

bool removeContrib (size_t objIdx)

Remove a contribution referenced by an index.

bool removeContrib ()

Remove all contributions.

bool resetContrib (const IParticle *pPart)

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

bool resetContrib (size_t objIdx)

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

bool resetContrib ()

Reset all contribution parameters.

Dedicated accessors for linked objects

const Jet * refJet () const

Access reference jet.

const JetContainer * refJetContainer () const

Access reference jet container holding reference jet.

size_t refJetIndex () const

Access index of reference jet in its container.

std::vector< const IParticle * > objects () const

Access contributing objects.

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

Access contributing objects and retrieve constituent vectors.

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

Access contributing objects and retrieve constituent vectors.

ConstVec calVec (const IParticle *pPart) const

Get calo constituent vector for a given object.

ConstVec calVec (size_t keyIdx) const

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

ConstVec trkVec (const IParticle *pPart) const

Get track constituent vector for a given object.

ConstVec trkVec (size_t keyIdx) const

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

ConstVec jetTrkVec () const

Get track constituent vector for the reference jet.

Adding and retrieving selection and overlap information

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

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

bool addOverlap (size_t objIdx, size_t index, unsigned char type)

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

bool identifyOverlaps ()

Loop over contributing objects to identify those that share constituents.

bool identifyOverlaps (size_t objIdx)

Search association for particles that share constituents with this one.

bool identifyOverlaps (const IParticle *pPart)

Search association for particles that share constituents with this one.

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

Check if any selected particles overlap this one.

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

Check if any selected particles overlap this one.

bool hasAlternateConstVec () const

xAOD::JetFourMom_t getAlternateConstVec () const

ConstVec overlapCalVec (const MissingETAssociationHelper &helper) const

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

ConstVec overlapTrkVec (const MissingETAssociationHelper &helper) const

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

bool containsSignal (const IParticle *pSig) const

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

bool containsPhysics (const IParticle *pPhys) const

Check if this physics object matches any contributing objects.

bool isMisc () const

Check if this association is a miscellaneous association.

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

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

Allocating and accessing objects in the contribution

size_t findIndex (const IParticle *pPart) const

Find index of given object in contributing object store.

List management and information

size_t size () const

Update all internally used ElementLink instances.

size_t sizeCal () const

size_t sizeTrk () const

bool empty () const

Empty list of contributing objects indicator.

Comparators

Parameters

[in] contrib reference to non-modifiable contribution object to compare to.

bool operator== (const MissingETAssociation_v1 &contrib) const

bool operator!= (const MissingETAssociation_v1 &contrib) const

Equality.

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

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

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

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

Private Attributes
std::map< const IParticle *, ConstVec >	m_override

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

Detailed Description

MET association descriptor contains object links and corresponding parameters.

Definition at line 24 of file MissingETAssociation_v1.h.

Constructor & Destructor Documentation

◆ MissingETAssociation_v1() [1/3]

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

explicit

Default constructor.

Definition at line 94 of file MissingETAssociation_v1.cxx.

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

◆ MissingETAssociation_v1() [2/3]

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

Construct with a link to a Jet object.

Definition at line 102 of file MissingETAssociation_v1.cxx.

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

◆ MissingETAssociation_v1() [3/3]

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

Copy constructor.

Definition at line 112 of file MissingETAssociation_v1.cxx.

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

◆ ~MissingETAssociation_v1()

xAOD::MissingETAssociation_v1::~MissingETAssociation_v1 ( )

virtual

Assignment operator.

Definition at line 146 of file MissingETAssociation_v1.cxx.

146{ }

Member Function Documentation

◆ addCalVec()

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

Add a key/vector pair for calo contributions.

Definition at line 345 of file MissingETAssociation_v1.cxx.

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

◆ addObject()

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

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

Definition at line 152 of file MissingETAssociation_v1.cxx.

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

◆ addOverlap() [1/2]

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

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

◆ addOverlap() [2/2]

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

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

Definition at line 589 of file MissingETAssociation_v1.cxx.

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

◆ addOverrideMom()

void xAOD::MissingETAssociation_v1::addOverrideMom ( std::map< const IParticle *, ConstVec > & pOverride )

Extend override momentum map.

◆ addTrkVec()

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

Add a key/vector pair for calo contributions.

Definition at line 379 of file MissingETAssociation_v1.cxx.

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

◆ cale() [1/2]

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

Get the vector of \( E \).

◆ cale() [2/2]

float xAOD::MissingETAssociation_v1::cale ( size_t keyIdx ) const

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

Definition at line 473 of file MissingETAssociation_v1.cxx.

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

xAOD::MissingETAssociation_v1::sizeCal

size_t sizeCal() const

MissingETBase::Numerical::ceError

static double ceError()

Access error return value for constituent vector .

Definition MissingETBase.h:101

◆ calkey() [1/2]

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

Get the vector of cal keys.

◆ calkey() [2/2]

MissingETBase::Types::bitmask_t xAOD::MissingETAssociation_v1::calkey ( size_t keyIdx ) const

Get the key for a given entry referenced by index.

Definition at line 477 of file MissingETAssociation_v1.cxx.

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

xAOD::MissingETAssociation_v1::calkey

const std::vector< MissingETBase::Types::bitmask_t > & calkey() const

Get the vector of cal keys.

◆ calpx() [1/3]

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

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

◆ calpx() [2/3]

float xAOD::MissingETAssociation_v1::calpx ( const IParticle * pPart ) const

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

◆ calpx() [3/3]

float xAOD::MissingETAssociation_v1::calpx ( size_t keyIdx ) const

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

Definition at line 467 of file MissingETAssociation_v1.cxx.

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

MissingETBase::Numerical::cpxError

static double cpxError()

Access error return value for constituent vector .

Definition MissingETBase.h:98

◆ calpy() [1/2]

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

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

◆ calpy() [2/2]

float xAOD::MissingETAssociation_v1::calpy ( size_t keyIdx ) const

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

Definition at line 469 of file MissingETAssociation_v1.cxx.

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

MissingETBase::Numerical::cpyError

static double cpyError()

Access error return value for constituent vector .

Definition MissingETBase.h:99

◆ calpz() [1/2]

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

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

◆ calpz() [2/2]

float xAOD::MissingETAssociation_v1::calpz ( size_t keyIdx ) const

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

Definition at line 471 of file MissingETAssociation_v1.cxx.

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

MissingETBase::Numerical::cpzError

static double cpzError()

Access error return value for constituent vector .

Definition MissingETBase.h:100

◆ calsumpt() [1/2]

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

Get the vector of sumpt.

◆ calsumpt() [2/2]

float xAOD::MissingETAssociation_v1::calsumpt ( size_t keyIdx ) const

Get the sumpt for a given object referenced by index.

Definition at line 475 of file MissingETAssociation_v1.cxx.

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

xAOD::MissingETAssociation_v1::calsumpt

const std::vector< float > & calsumpt() const

Get the vector of sumpt.

MissingETBase::Numerical::sumptError

static double sumptError()

Access error return value for constituent vector sumpt.

Definition MissingETBase.h:102

◆ calVec() [1/2]

MissingETAssociation_v1::ConstVec xAOD::MissingETAssociation_v1::calVec ( const IParticle * pPart ) const

Get calo constituent vector for a given object.

Definition at line 538 of file MissingETAssociation_v1.cxx.

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

◆ calVec() [2/2]

constvec_t xAOD::MissingETAssociation_v1::calVec ( size_t keyIdx ) const

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

Definition at line 558 of file MissingETAssociation_v1.cxx.

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

◆ checkUsage()

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

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

Definition at line 816 of file MissingETAssociation_v1.cxx.

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

◆ clearCalVecs()

bool xAOD::MissingETAssociation_v1::clearCalVecs ( )

Reset the calo constituent vectors and keys.

◆ clearOverlaps()

void xAOD::MissingETAssociation_v1::clearOverlaps ( )

Clear the vectors of overlap indices.

Definition at line 411 of file MissingETAssociation_v1.cxx.

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

◆ clearTrkVecs()

bool xAOD::MissingETAssociation_v1::clearTrkVecs ( )

Reset the track constituent vectors and keys.

◆ containsPhysics()

bool xAOD::MissingETAssociation_v1::containsPhysics ( const IParticle * pPhys ) const

Check if this physics object matches any contributing objects.

Definition at line 790 of file MissingETAssociation_v1.cxx.

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

◆ containsSignal()

bool xAOD::MissingETAssociation_v1::containsSignal ( const IParticle * pSig ) const

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

Definition at line 802 of file MissingETAssociation_v1.cxx.

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

◆ copyData()

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

protected

◆ createPrivateStore()

void xAOD::MissingETAssociation_v1::createPrivateStore ( )

protected

Function initialising the object to work in standalone mode.

Definition at line 836 of file MissingETAssociation_v1.cxx.

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

◆ empty()

bool xAOD::MissingETAssociation_v1::empty ( ) const

Empty list of contributing objects indicator.

◆ f_cale()

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

protected

◆ f_calkey()

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

protected

◆ f_calpx()

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

protected

◆ f_calpy()

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

protected

◆ f_calpz()

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

protected

◆ f_calsumpt()

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

protected

◆ f_isMisc()

char & xAOD::MissingETAssociation_v1::f_isMisc ( )

protected

◆ f_jetLink()

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

protected

Non-const link reference.

◆ f_jettrke()

float & xAOD::MissingETAssociation_v1::f_jettrke ( )

protected

◆ f_jettrkpx()

float & xAOD::MissingETAssociation_v1::f_jettrkpx ( )

protected

◆ f_jettrkpy()

float & xAOD::MissingETAssociation_v1::f_jettrkpy ( )

protected

◆ f_jettrkpz()

float & xAOD::MissingETAssociation_v1::f_jettrkpz ( )

protected

◆ f_jettrksumpt()

float & xAOD::MissingETAssociation_v1::f_jettrksumpt ( )

protected

◆ f_objectLinks()

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

protected

Non-const link reference.

◆ f_overlapIndices()

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

protected

record overlapIndices between constributing objects

◆ f_overlapTypes()

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

protected

record overlapTypes between constributing objects

◆ f_removeContrib()

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

protected

Copy the contribution data from a source.

Parameters

[in] contrib reference to non-modifiable contribution object (the source).

Definition at line 218 of file MissingETAssociation_v1.cxx.

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

◆ f_setLink()

template<class LINK>

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

protected

◆ f_setObject()

template<class POBJ, class LINK>

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

protected

Generalized link manager.

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

Template Parameters

POBJ	linked object type
LINK	specific ElementLink type

Parameters

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

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

◆ f_trke()

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

protected

◆ f_trkkey()

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

protected

◆ f_trkpx()

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

protected

◆ f_trkpy()

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

protected

◆ f_trkpz()

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

protected

◆ f_trksumpt()

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

protected

◆ findCalIndex()

size_t xAOD::MissingETAssociation_v1::findCalIndex ( MissingETBase::Types::bitmask_t mask ) const

Definition at line 281 of file MissingETAssociation_v1.cxx.

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

◆ findIndex()

size_t xAOD::MissingETAssociation_v1::findIndex ( const IParticle * pPart ) const

Find index of given object in contributing object store.

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

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

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

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

Parameters

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

Definition at line 266 of file MissingETAssociation_v1.cxx.

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

◆ findTrkIndex()

size_t xAOD::MissingETAssociation_v1::findTrkIndex ( MissingETBase::Types::bitmask_t mask ) const

Definition at line 287 of file MissingETAssociation_v1.cxx.

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

◆ getAlternateConstVec()

xAOD::JetFourMom_t xAOD::MissingETAssociation_v1::getAlternateConstVec ( ) const

Definition at line 757 of file MissingETAssociation_v1.cxx.

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

◆ hasAlternateConstVec()

bool xAOD::MissingETAssociation_v1::hasAlternateConstVec ( ) const

Definition at line 752 of file MissingETAssociation_v1.cxx.

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

◆ hasOverlaps() [1/2]

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

Check if any selected particles overlap this one.

◆ hasOverlaps() [2/2]

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

Check if any selected particles overlap this one.

Definition at line 717 of file MissingETAssociation_v1.cxx.

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

◆ identifyOverlaps() [1/3]

bool xAOD::MissingETAssociation_v1::identifyOverlaps ( )

Loop over contributing objects to identify those that share constituents.

Definition at line 598 of file MissingETAssociation_v1.cxx.

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

◆ identifyOverlaps() [2/3]

bool xAOD::MissingETAssociation_v1::identifyOverlaps ( const IParticle * pPart )

Search association for particles that share constituents with this one.

◆ identifyOverlaps() [3/3]

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

Search association for particles that share constituents with this one.

Definition at line 678 of file MissingETAssociation_v1.cxx.

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

◆ initCache()

void xAOD::MissingETAssociation_v1::initCache ( )

protected

initialise cache for overlap removal decisions

Definition at line 866 of file MissingETAssociation_v1.cxx.

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

◆ isMisc()

bool xAOD::MissingETAssociation_v1::isMisc ( ) const

Check if this association is a miscellaneous association.

◆ jetLink()

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

Get the link to the reference jet.

◆ jettrke()

float xAOD::MissingETAssociation_v1::jettrke ( ) const

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

◆ jettrkpx()

float xAOD::MissingETAssociation_v1::jettrkpx ( ) const

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

◆ jettrkpy()

float xAOD::MissingETAssociation_v1::jettrkpy ( ) const

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

◆ jettrkpz()

float xAOD::MissingETAssociation_v1::jettrkpz ( ) const

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

◆ jettrksumpt()

float xAOD::MissingETAssociation_v1::jettrksumpt ( ) const

Get the sumpt for a given object referenced by index.

◆ jetTrkVec()

constvec_t xAOD::MissingETAssociation_v1::jetTrkVec ( ) const

Get track constituent vector for the reference jet.

Definition at line 568 of file MissingETAssociation_v1.cxx.

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

xAOD::MissingETAssociation_v1::jettrkpx

float jettrkpx() const

Get the vector for a given object referenced by index.

xAOD::MissingETAssociation_v1::jettrkpy

float jettrkpy() const

Get the vector for a given object referenced by pointer.

xAOD::MissingETAssociation_v1::jettrkpz

float jettrkpz() const

Get the vector for a given object referenced by pointer.

xAOD::MissingETAssociation_v1::jettrksumpt

float jettrksumpt() const

Get the sumpt for a given object referenced by index.

xAOD::MissingETAssociation_v1::jettrke

float jettrke() const

Get the vector for a given object referenced by index.

◆ objectLinks()

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

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

◆ objects() [1/3]

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

Access contributing objects.

Definition at line 503 of file MissingETAssociation_v1.cxx.

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

◆ objects() [2/3]

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

Access contributing objects and retrieve constituent vectors.

Definition at line 522 of file MissingETAssociation_v1.cxx.

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

◆ objects() [3/3]

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

Access contributing objects and retrieve constituent vectors.

Definition at line 510 of file MissingETAssociation_v1.cxx.

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

◆ operator!=()

bool xAOD::MissingETAssociation_v1::operator!= ( const MissingETAssociation_v1 & contrib ) const

Equality.

◆ operator=()

MissingETAssociation_v1 & xAOD::MissingETAssociation_v1::operator= ( const MissingETAssociation_v1 & assocDescr )

Definition at line 119 of file MissingETAssociation_v1.cxx.

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

◆ operator==()

bool xAOD::MissingETAssociation_v1::operator== ( const MissingETAssociation_v1 & contrib ) const

Definition at line 575 of file MissingETAssociation_v1.cxx.

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

◆ overlapCalVec()

constvec_t xAOD::MissingETAssociation_v1::overlapCalVec ( const MissingETAssociationHelper & helper ) const

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

Definition at line 770 of file MissingETAssociation_v1.cxx.

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

◆ overlapIndices() [1/3]

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

Get the list of object overlapIndices.

◆ overlapIndices() [2/3]

std::vector< size_t > xAOD::MissingETAssociation_v1::overlapIndices ( const IParticle * pPart ) const

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

◆ overlapIndices() [3/3]

std::vector< size_t > xAOD::MissingETAssociation_v1::overlapIndices ( size_t objIdx ) const

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

Definition at line 493 of file MissingETAssociation_v1.cxx.

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

◆ overlapTrkVec()

constvec_t xAOD::MissingETAssociation_v1::overlapTrkVec ( const MissingETAssociationHelper & helper ) const

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

Definition at line 780 of file MissingETAssociation_v1.cxx.

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

◆ overlapTypes() [1/3]

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

Get the list of object overlapTypes.

◆ overlapTypes() [2/3]

std::vector< unsigned char > xAOD::MissingETAssociation_v1::overlapTypes ( const IParticle * pPart ) const

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

◆ overlapTypes() [3/3]

std::vector< unsigned char > xAOD::MissingETAssociation_v1::overlapTypes ( size_t objIdx ) const

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

Definition at line 498 of file MissingETAssociation_v1.cxx.

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

◆ overrideMom()

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

Get override momenta.

◆ refJet()

const Jet * xAOD::MissingETAssociation_v1::refJet ( ) const

Access reference jet.

◆ refJetContainer()

const JetContainer * xAOD::MissingETAssociation_v1::refJetContainer ( ) const

Access reference jet container holding reference jet.

◆ refJetIndex()

size_t xAOD::MissingETAssociation_v1::refJetIndex ( ) const

Access index of reference jet in its container.

◆ removeContrib() [1/3]

bool xAOD::MissingETAssociation_v1::removeContrib ( )

Remove all contributions.

Definition at line 211 of file MissingETAssociation_v1.cxx.

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

◆ removeContrib() [2/3]

bool xAOD::MissingETAssociation_v1::removeContrib ( const IParticle * pPart )

Remove a contribution referenced by an object pointer.

◆ removeContrib() [3/3]

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

Remove a contribution referenced by an index.

◆ resetContrib() [1/3]

bool xAOD::MissingETAssociation_v1::resetContrib ( )

Reset all contribution parameters.

Definition at line 247 of file MissingETAssociation_v1.cxx.

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

◆ resetContrib() [2/3]

bool xAOD::MissingETAssociation_v1::resetContrib ( const IParticle * pPart )

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

◆ resetContrib() [3/3]

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

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

Definition at line 241 of file MissingETAssociation_v1.cxx.

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

◆ setCalE() [1/2]

bool xAOD::MissingETAssociation_v1::setCalE ( const std::vector< float > & calevec )

Set the vector of \( E \).

Definition at line 303 of file MissingETAssociation_v1.cxx.

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

◆ setCalE() [2/2]

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

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

Definition at line 331 of file MissingETAssociation_v1.cxx.

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

◆ setCalKey() [1/2]

bool xAOD::MissingETAssociation_v1::setCalKey ( const std::vector< MissingETBase::Types::bitmask_t > & calkeyvec )

Set the vector of keys.

Definition at line 307 of file MissingETAssociation_v1.cxx.

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

◆ setCalKey() [2/2]

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

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

Definition at line 335 of file MissingETAssociation_v1.cxx.

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

◆ setCalPx() [1/2]

bool xAOD::MissingETAssociation_v1::setCalPx ( const std::vector< float > & calpxvec )

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

Definition at line 297 of file MissingETAssociation_v1.cxx.

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

◆ setCalPx() [2/2]

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

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

Definition at line 325 of file MissingETAssociation_v1.cxx.

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

◆ setCalPy() [1/2]

bool xAOD::MissingETAssociation_v1::setCalPy ( const std::vector< float > & calpyvec )

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

Definition at line 299 of file MissingETAssociation_v1.cxx.

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

◆ setCalPy() [2/2]

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

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

Definition at line 327 of file MissingETAssociation_v1.cxx.

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

◆ setCalPz() [1/2]

bool xAOD::MissingETAssociation_v1::setCalPz ( const std::vector< float > & calpzvec )

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

Definition at line 301 of file MissingETAssociation_v1.cxx.

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

◆ setCalPz() [2/2]

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

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

Definition at line 329 of file MissingETAssociation_v1.cxx.

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

◆ setCalSumpt() [1/2]

bool xAOD::MissingETAssociation_v1::setCalSumpt ( const std::vector< float > & calsumptvec )

Set the vector of sumpt.

Definition at line 305 of file MissingETAssociation_v1.cxx.

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

◆ setCalSumpt() [2/2]

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

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

Definition at line 333 of file MissingETAssociation_v1.cxx.

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

◆ setCalVec() [1/2]

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

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

◆ setCalVec() [2/2]

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

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

Definition at line 337 of file MissingETAssociation_v1.cxx.

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

◆ setJetLink()

bool xAOD::MissingETAssociation_v1::setJetLink ( const MissingETBase::Types::jetlink_t & jetLnk )

Set the link to the reference jet.

Definition at line 448 of file MissingETAssociation_v1.cxx.

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

◆ setJetTrkE()

void xAOD::MissingETAssociation_v1::setJetTrkE ( float e )

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

Definition at line 400 of file MissingETAssociation_v1.cxx.

401 { this->f_jettrke() = e; }

xAOD::e

setPy e

Definition CompositeParticle_v1.cxx:166

◆ setJetTrkPx()

void xAOD::MissingETAssociation_v1::setJetTrkPx ( float px )

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

Definition at line 394 of file MissingETAssociation_v1.cxx.

395 { this->f_jettrkpx() = px; }

test_pyathena.px

px

Definition test_pyathena.py:18

◆ setJetTrkPy()

void xAOD::MissingETAssociation_v1::setJetTrkPy ( float py )

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

Definition at line 396 of file MissingETAssociation_v1.cxx.

397 { this->f_jettrkpy() = py; }

xAOD::py

py

Definition CompositeParticle_v1.cxx:160

◆ setJetTrkPz()

void xAOD::MissingETAssociation_v1::setJetTrkPz ( float pz )

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

Definition at line 398 of file MissingETAssociation_v1.cxx.

399 { this->f_jettrkpz() = pz; }

Amg::pz

@ pz

Definition GeoPrimitives.h:40

◆ setJetTrkSumpt()

void xAOD::MissingETAssociation_v1::setJetTrkSumpt ( float sumpt )

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

Definition at line 402 of file MissingETAssociation_v1.cxx.

403 { this->f_jettrksumpt() = sumpt; }

◆ setJetTrkVec() [1/2]

void xAOD::MissingETAssociation_v1::setJetTrkVec ( const ConstVec & cvec = ConstVec() )

Set the track constituent vector for the reference jet.

◆ setJetTrkVec() [2/2]

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

Set the track constituent vector for the reference jet.

Definition at line 404 of file MissingETAssociation_v1.cxx.

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

◆ setObjectLinks()

bool xAOD::MissingETAssociation_v1::setObjectLinks ( const MissingETBase::Types::objlink_vector_t & objLnks )

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

Definition at line 455 of file MissingETAssociation_v1.cxx.

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

◆ setOverlaps() [1/3]

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

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

◆ setOverlaps() [2/3]

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

Set the vector of overlap indices and types.

Definition at line 418 of file MissingETAssociation_v1.cxx.

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

◆ setOverlaps() [3/3]

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

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

Definition at line 424 of file MissingETAssociation_v1.cxx.

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

◆ setOverrideMom()

void xAOD::MissingETAssociation_v1::setOverrideMom ( const std::map< const IParticle *, ConstVec > & pOverride )

Set override momenta.

◆ setRefJet() [1/2]

bool xAOD::MissingETAssociation_v1::setRefJet ( const Jet * pJet )

Set reference jet by object pointer reference.

Definition at line 434 of file MissingETAssociation_v1.cxx.

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

◆ setRefJet() [2/2]

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

Set reference jet by container pointer and index reference.

Definition at line 441 of file MissingETAssociation_v1.cxx.

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

◆ setTrkE() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkE ( const std::vector< float > & trkevec )

Set the vector of \( E \).

Definition at line 316 of file MissingETAssociation_v1.cxx.

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

◆ setTrkE() [2/2]

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

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

Definition at line 365 of file MissingETAssociation_v1.cxx.

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

◆ setTrkKey() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkKey ( const std::vector< MissingETBase::Types::bitmask_t > & trkkeyvec )

Set the vector of keys.

Definition at line 320 of file MissingETAssociation_v1.cxx.

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

◆ setTrkKey() [2/2]

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

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

Definition at line 369 of file MissingETAssociation_v1.cxx.

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

◆ setTrkPx() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkPx ( const std::vector< float > & trkpxvec )

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

Definition at line 310 of file MissingETAssociation_v1.cxx.

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

◆ setTrkPx() [2/2]

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

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

Definition at line 359 of file MissingETAssociation_v1.cxx.

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

◆ setTrkPy() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkPy ( const std::vector< float > & trkpyvec )

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

Definition at line 312 of file MissingETAssociation_v1.cxx.

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

◆ setTrkPy() [2/2]

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

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

Definition at line 361 of file MissingETAssociation_v1.cxx.

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

◆ setTrkPz() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkPz ( const std::vector< float > & trkpzvec )

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

Definition at line 314 of file MissingETAssociation_v1.cxx.

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

◆ setTrkPz() [2/2]

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

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

Definition at line 363 of file MissingETAssociation_v1.cxx.

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

◆ setTrkSumpt() [1/2]

bool xAOD::MissingETAssociation_v1::setTrkSumpt ( const std::vector< float > & trksumptvec )

Set the vector of \( E \).

Definition at line 318 of file MissingETAssociation_v1.cxx.

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

◆ setTrkSumpt() [2/2]

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

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

Definition at line 367 of file MissingETAssociation_v1.cxx.

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

◆ setTrkVec() [1/2]

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

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

◆ setTrkVec() [2/2]

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

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

Definition at line 371 of file MissingETAssociation_v1.cxx.

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

◆ size()

size_t xAOD::MissingETAssociation_v1::size ( ) const

Update all internally used ElementLink instances.

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

[Deprecated] Update link to reference jet only

◆ sizeCal()

size_t xAOD::MissingETAssociation_v1::sizeCal ( ) const

◆ sizeTrk()

size_t xAOD::MissingETAssociation_v1::sizeTrk ( ) const

◆ testPolicy() [1/2]

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

static

Definition at line 873 of file MissingETAssociation_v1.cxx.

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

◆ testPolicy() [2/2]

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

staticprotected

Definition at line 879 of file MissingETAssociation_v1.cxx.

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

◆ trke() [1/2]

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

Get the vector of \( E \).

◆ trke() [2/2]

float xAOD::MissingETAssociation_v1::trke ( size_t keyIdx ) const

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

Definition at line 486 of file MissingETAssociation_v1.cxx.

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

◆ trkkey() [1/2]

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

Get the vector of trk keys.

◆ trkkey() [2/2]

MissingETBase::Types::bitmask_t xAOD::MissingETAssociation_v1::trkkey ( size_t keyIdx ) const

Get the key for a given entry referenced by index.

Definition at line 490 of file MissingETAssociation_v1.cxx.

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

◆ trkpx() [1/2]

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

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

◆ trkpx() [2/2]

float xAOD::MissingETAssociation_v1::trkpx ( size_t keyIdx ) const

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

Definition at line 480 of file MissingETAssociation_v1.cxx.

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

◆ trkpy() [1/2]

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

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

◆ trkpy() [2/2]

float xAOD::MissingETAssociation_v1::trkpy ( size_t keyIdx ) const

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

Definition at line 482 of file MissingETAssociation_v1.cxx.

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

◆ trkpz() [1/2]

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

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

◆ trkpz() [2/2]

float xAOD::MissingETAssociation_v1::trkpz ( size_t keyIdx ) const

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

Definition at line 484 of file MissingETAssociation_v1.cxx.

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

◆ trksumpt() [1/2]

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

Get the vector of \( E \).

◆ trksumpt() [2/2]

float xAOD::MissingETAssociation_v1::trksumpt ( size_t keyIdx ) const

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

Definition at line 488 of file MissingETAssociation_v1.cxx.

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

◆ trkVec() [1/2]

MissingETAssociation_v1::ConstVec xAOD::MissingETAssociation_v1::trkVec ( const IParticle * pPart ) const

Get track constituent vector for a given object.

Definition at line 548 of file MissingETAssociation_v1.cxx.

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

◆ trkVec() [2/2]

constvec_t xAOD::MissingETAssociation_v1::trkVec ( size_t keyIdx ) const

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

Definition at line 563 of file MissingETAssociation_v1.cxx.

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

Member Data Documentation

◆ m_acc_cale

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

staticprivate

Definition at line 431 of file MissingETAssociation_v1.h.

◆ m_acc_calpx

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

staticprivate

Definition at line 428 of file MissingETAssociation_v1.h.

◆ m_acc_calpy

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

staticprivate

Definition at line 429 of file MissingETAssociation_v1.h.

◆ m_acc_calpz

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

staticprivate

Definition at line 430 of file MissingETAssociation_v1.h.

◆ m_acc_calsumpt

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

staticprivate

Definition at line 432 of file MissingETAssociation_v1.h.

◆ m_acc_jettrke

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

staticprivate

Definition at line 443 of file MissingETAssociation_v1.h.

◆ m_acc_jettrkpx

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

staticprivate

Definition at line 440 of file MissingETAssociation_v1.h.

◆ m_acc_jettrkpy

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

staticprivate

Definition at line 441 of file MissingETAssociation_v1.h.

◆ m_acc_jettrkpz

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

staticprivate

Definition at line 442 of file MissingETAssociation_v1.h.

◆ m_acc_jettrksumpt

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

staticprivate

Definition at line 444 of file MissingETAssociation_v1.h.

◆ m_acc_trke

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

staticprivate

Definition at line 437 of file MissingETAssociation_v1.h.

◆ m_acc_trkpx

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

staticprivate

Definition at line 434 of file MissingETAssociation_v1.h.

◆ m_acc_trkpy

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

staticprivate

Definition at line 435 of file MissingETAssociation_v1.h.

◆ m_acc_trkpz

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

staticprivate

Definition at line 436 of file MissingETAssociation_v1.h.

◆ m_acc_trksumpt

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

staticprivate

Definition at line 438 of file MissingETAssociation_v1.h.

◆ m_objConstLinks

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

protected

Cache object constituents for overlap-finding.

Definition at line 423 of file MissingETAssociation_v1.h.

◆ m_override

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

private

Definition at line 426 of file MissingETAssociation_v1.h.

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

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MissingETAssociation_v1() [1/3]

◆ MissingETAssociation_v1() [2/3]

◆ MissingETAssociation_v1() [3/3]

◆ ~MissingETAssociation_v1()

Member Function Documentation

◆ addCalVec()

◆ addObject()

◆ addOverlap() [1/2]

◆ addOverlap() [2/2]

◆ addOverrideMom()

◆ addTrkVec()

◆ cale() [1/2]

◆ cale() [2/2]

◆ calkey() [1/2]

◆ calkey() [2/2]

◆ calpx() [1/3]

◆ calpx() [2/3]

◆ calpx() [3/3]

◆ calpy() [1/2]

◆ calpy() [2/2]

◆ calpz() [1/2]

◆ calpz() [2/2]

◆ calsumpt() [1/2]

◆ calsumpt() [2/2]

◆ calVec() [1/2]

◆ calVec() [2/2]

◆ checkUsage()

◆ clearCalVecs()

◆ clearOverlaps()

◆ clearTrkVecs()

◆ containsPhysics()

◆ containsSignal()

◆ copyData()

◆ createPrivateStore()

◆ empty()

◆ f_cale()

◆ f_calkey()

◆ f_calpx()

◆ f_calpy()

◆ f_calpz()

◆ f_calsumpt()

◆ f_isMisc()

◆ f_jetLink()

◆ f_jettrke()

◆ f_jettrkpx()

◆ f_jettrkpy()

◆ f_jettrkpz()

◆ f_jettrksumpt()

◆ f_objectLinks()

◆ f_overlapIndices()

◆ f_overlapTypes()

◆ f_removeContrib()

◆ f_setLink()

◆ f_setObject()

◆ f_trke()

◆ f_trkkey()

◆ f_trkpx()

◆ f_trkpy()

◆ f_trkpz()

◆ f_trksumpt()

◆ findCalIndex()

◆ findIndex()

◆ findTrkIndex()

◆ getAlternateConstVec()

◆ hasAlternateConstVec()

◆ hasOverlaps() [1/2]

◆ hasOverlaps() [2/2]

◆ identifyOverlaps() [1/3]

◆ identifyOverlaps() [2/3]

◆ identifyOverlaps() [3/3]