xAOD::MissingET_v1 Class Reference

Principal data object for Missing ET. More...

#include <MissingET_v1.h>

Inheritance diagram for xAOD::MissingET_v1:
SG::AuxElement SG::IAuxElement

List of all members.

Public Member Functions

Constructors and destructor



 MissingET_v1 (bool createStore=false)
 Default constructor.
 MissingET_v1 (const std::string &name, MissingETBase::Types::bitmask_t src=MissingETBase::Source::unknown())
 Constructor with identifiers.
 MissingET_v1 (const IParticle *particle, const std::string &name="MissingET", MissingETBase::Types::bitmask_t src=MissingETBase::Source::unknown())
 Constructor with particle.
 MissingET_v1 (double mpx, double mpy, double sumet, const std::string &name="MissingET", MissingETBase::Types::bitmask_t src=MissingETBase::Source::unknown())
 Constructor with initial kinematics.
 MissingET_v1 (const MissingET_v1 &met)
 Copy constructor.
 ~MissingET_v1 ()
 Implementation class destructor.
Kinematic accessors



double mpx () const
 Returns $ p_{x}^{\rm miss} $.
double mpy () const
 Returns $ p_{y}^{\rm miss} $.
double met () const
 Returns $ E_{\rm T}^{\rm miss} = \sqrt{(p_{x}^{\rm miss})^{2} + (p_{y}^{\rm miss})^{2}} $.
double phi () const
 Returns $ \phi(E_{\rm T}^{\rm miss}) $.
double sumet () const
 Returns.
Kinematic setters



void setMpx (double value)
 Set the $ p_{x}^{\rm miss} $ component.
void setMpy (double value)
 Set the $ p_{y}^{\rm miss} $ component.
void setSumet (double value)
 Set $ \Sigma E_{\rm T} $.



const std::string & name () const
 Identifier getters.
MissingETBase::Types::bitmask_t source () const
 MET object source tag.
const std::size_t & nameHash () const
 Return hash associated to the MET object name.
Identifier setters



void setName (const std::string &name)
 Set the name of the MET object.
void setSource (MissingETBase::Types::bitmask_t src)
 Set the source of the MET object.
Manipulating the kinematic data



void add (const IParticle *particle)
 Add particle kinematics to MET.
void add (const IParticle *particle, double scale)
 Add scaled particle kinematics to MET.
void add (double px, double py, double pt)
 Add kinematic variables to MET.
MissingET_v1 & operator= (const MissingET_v1 &met)
 Add particle kinematics to MET.
MissingET_v1 & operator+= (const IParticle *particle)
 Add particle kinematics to MET.
MissingET_v1 & operator-= (const IParticle *part)
 Remove particle kinematics to MET.
MET object algebra



MissingET_v1 & operator+= (const MissingET_v1 &met)
 Add another MET object.
MissingET_v1 & operator-= (const MissingET_v1 &met)
 Subtract another MET object.
MissingET_v1 & operator*= (double scale)
 Applying a scale factor.
MissingET_v1 & operator/= (double scale)
 Dividing by a scale factor.
Stored data management



void clear ()
 Clear/reset the data store.
Comparators



bool operator== (const MissingET_v1 &met) const
 Equality test.
bool operator!= (const MissingET_v1 &met) const
 Inequality test.

Protected Member Functions

void createPrivateStore ()
 Function initialising the object to work in standalone mode.
Internal data modification support



double & f_mpx ()
 Returns reference to $ p_{x} $ store.
double & f_mpy ()
 Returns reference to $ p_{y} $ store.
double & f_sumet ()
 Returns reference to $ \Sigma E_{\rm T} $ store.
std::string & f_name ()
 Returns reference to MET object name store.
MissingETBase::Types::bitmask_t & f_source ()
 Returns reference to MET object source store.

Detailed Description

Principal data object for Missing ET.

This object provides the data store for the missing transverse momentum (MET) components $(p_{x},p_{y},\Sigma E_{\rmT}) $. In addition, each xAOD::MissingET_v1 object stores the name of the MET term it represents, and a source indicator. The object can be instantiated as a default (no-op) object without a datastore , or a fully functional plain-old-data (POD) object with a private data store. The latter is supported by constructors with just name and source indicator , initial kinematics are set to zero), and constructors storing (initial or final) kinematic contributions, either from a physics or signal object reference or from individually specified kinematics .

Note:
This object is designed to store only the summed kinematics of a MET term, together with some identifiers. The actual contribution to this term from any physics or signal object to this MET term is not stored here, but in a dedicated MET component object .

Adding kinematics to a MET term implies to use the correct convention, which is given by

\begin{eqnarray*} p_{x}^{\rm miss} & = & - \sum p_{x} \\ p_{y}^{\rm miss} & = & - \sum p_{y} \\ \Sigma E_{\rm T} & = & \sum p_{\rm T}. \end{eqnarray*}

Here $ p_{x,y} $ and $ p_{\rm T} $ are the transverse momentum and its components of the particle (or detector signal object) added to the MET object. This convention is implemented by the xAOD::MissingET_v1::add() method, which is highly recommended to be used to fill the MET term.

MET data are initially represented in indivdual, non-storable data objects. As mentioned above, each of these data objects typically contains the contribution from a set of same type final state objects like particles and jets, and is identified as a specific contribution by a name and a source indicator (bit pattern). In general all MET objects from the various sources contribute to a given MET reconstruction configuration and their sum is the overall MET for the event. For storage, and to indicated that a given xAOD::MissingET_v1 object represents a certain MET term in a given MET reconstruction configuration, the individual MET objects are collected into a xAOD::MissingETContainer_v1 object. Typically, the insertion sequence (e.g. the index of an individual MET object) in this container is determined by the tool sequence with which the MET terms are reconstructed, there is no particular enforcement of this rule in the EDM. Safe (random) accessors using the name or the source indicator of the requested MET object are provided by the MET object.

Author:
Peter Loch <loch_AT_physics.arizona.edu>
Silvia Resconi <Silvia.Resconi_AT_cern.ch>
Date:
Feb. 20, 2014
Version:
v1.0 (for release 19.0.1)

Constructor & Destructor Documentation

xAOD::MissingET_v1::MissingET_v1 ( bool  createStore = false  )  [explicit]

Default constructor.

This constructor generates a no-op object without an attached store, if invoked with its default argument, which is the same as explicitly invoking it the argument false.

Parameters:
[in] createStore flags if private store should be created (true) or not (false) (optional, default is false - no private store)
Note:
The default constructor is provided in accordance with requirements for the general xAOD EDM design. An object constructed this way does not provide a data store, and any use of an accessor method for such an object may lead to undesired behaviour and program crashes.
xAOD::MissingET_v1::MissingET_v1 ( const std::string &  name = "MissingET",
MissingETBase::Types::bitmask_t  src = MissingETBase::Source::unknown() 
)

Constructor with identifiers.

A MET object with a name and and (optional) source indicator is constructed. The initiat MET components $ (p_{x},p_{y},\Sigma E_{\rm T}) $ are each set to zero.

Parameters:
[in] name argument providing a name for the MissingET_v1 object, default "MissingET"
[in] src optional argument providing the source tag, default is "unknown" MissingETBase::Source::unknown().
Note:
This constructors instantiates a MET object with a private data store for the kinematics with meaningful inditial values, and the given name and source indicator. While the object instantiated this way is not storable, it is otherwise a fully usable.
xAOD::MissingET_v1::MissingET_v1 ( const IParticle *  particle,
const std::string &  name = "MissingET",
MissingETBase::Types::bitmask_t  src = MissingETBase::Source::unknown() 
)

Constructor with particle.

A MET object with a name (optional) and a source indicator (optional) is constructed. The initial MET components $ (p_{x},p_{y},\Sigma E_{\rm T}) $ are each set to the corresponding components in the particle.

Parameters:
[in] particle reference to particle with initial kinematics
[in] name optional argument providing a name for the MissingET_v1 object, default "MissingET"
[in] src optional argument providing the source tag, default is "unknown" MissingETBase::Source::unknown().
Note:
This constructors instantiates a MET object with a private data store for the kinematics with meaningful inditial values, and the given name and source indicator. While the object instantiated this way is not storable, it is otherwise a fully usable.
xAOD::MissingET_v1::MissingET_v1 ( double  mpx,
double  mpy,
double  pt,
const std::string &  name = "MissingET",
MissingETBase::Types::bitmask_t  src = MissingETBase::Source::unknown() 
)

Constructor with initial kinematics.

A MET object with a name (optional) and a source indicator (optional) is constructed. The initial MET components $ (p_{x},p_{y},\Sigma E_{\rm T}) $ are given in the argument list.

Parameters:
[in] mpx momentum component $ p_{x} $
[in] mpy momentum component $ p_{y} $
[in] pt momentum component $ p_{\rm T} $
[in] name optional argument providing a name for the MissingET_v1 object, default "MissingET"
[in] src optional argument providing the source tag, default is "unknown" MissingETBase::Source::unknown().
Note:
This constructors instantiates a MET object with a private data store for the kinematics with meaningful inditial values, and the given name and source indicator. While the object instantiated this way is not storable, it is otherwise a fully usable. Not enforcing $ p_{\rm T} = \sqrt{ p_{x}^{2} + p_{y}^{2} } $ is intentional, as in principle the MET components ( $ E_{\rm T}^{\rm miss} $ ) can have a different scale than the scalar transverse momentum sum $ \Sigma E_{\rm T} $ .
xAOD::MissingET_v1::MissingET_v1 ( const MissingET_v1 &  met  ) 

Copy constructor.

Provides a deep copy of the MET object. The constructed MissingET_v1 object does not share its AuxElement with the source object. If the source object is incomplete (has no data store), the resulting object does not have a data store either.

Note:
The particular behaviour concerning the data store depends on the actual implementation of SG::AuxElement::makePrivateStore.

[in] met reference to non-modifiable MET object (the source).

Member Function Documentation

void xAOD::MissingET_v1::add ( const IParticle *  particle,
double  scale 
)

Add scaled particle kinematics to MET.

Here the particle kinematics is added to the MET object with a common scale factor. This method updates the internal data stores. If each MET component needs a different scale, xAOD::MissingET_v1::add(double,double,double) can be used.

Parameters:
[in] particle pointer to the particle object
[in] scale scale factor

This method updates the internal data stores holding $ (p_{x},p_{y},\Sigma E_{\rm T}) $ like:

\begin{eqnarray*} p_{x}^{\rm miss} & \to & p_{x}^{\rm miss} - f \cdot p_{x}^{\rm particle} \\ p_{y}^{\rm miss} & \to & p_{y}^{\rm miss} - f \cdot p_{y}^{\rm particle} \\ \Sigma E_{\rm T} & \to & \Sigma E_{\rm T} + f \cdot p_{\rm T}^{\rm particle} . \end{eqnarray*}

The particle momentum components contributing to MET are $ p_{x}^{\rm particle} $, $ p_{y}^{\rm particle} $, and $ p_{\rm T}^{\rm particle} $. The scale factor if $ f $.

Note:
There is no reference to the particle object added to the MET object. Its composition can be stored in a MissingETComponent_v1 object, but this has to be explicitly done by the user.
void xAOD::MissingET_v1::add ( const IParticle *  particle  ) 

Add particle kinematics to MET.

The particle kinematics is added to MET.

Parameters:
[in] particle pointer to the particle object

This method updates the internal data stores holding $ (p_{x},p_{y},\Sigma E_{\rm T}) $ like:

\begin{eqnarray*} p_{x}^{\rm miss} & \to & p_{x}^{\rm miss} - p_{x}^{\rm particle} \\ p_{y}^{\rm miss} & \to & p_{y}^{\rm miss} - p_{y}^{\rm particle} \\ \Sigma E_{\rm T} & \to & \Sigma E_{\rm T} + p_{\rm T}^{\rm particle} . \end{eqnarray*}

The particle momentum components contributing to MET are $ p_{x}^{\rm particle} $, $ p_{y}^{\rm particle} $, and $ p_{\rm T}^{\rm particle} $.

Note:
There is no reference to the particle object added to the MET object. Its composition can be stored in a MissingETComponent_v1 object, but this has to be explicitly done by the user.
void xAOD::MissingET_v1::clear (  )  [inline]

Clear/reset the data store.

This function sets $ p_{x} = 0 $, $ p_{y} = 0 $, and $ \Sigma E_{\rm T} = 0 $. The name and the source indicator of this MET object are not changed.

void MissingET_v1::createPrivateStore (  )  [protected]

Function initialising the object to work in standalone mode.

This function is added because in standalone mode we can't use C++11. So we can't rely on constructors calling each other. Which means that the same functionality is instead now implemented in this old style.

const std::string & xAOD::MissingET_v1::f_name (  )  [inline, protected]

Returns reference to MET object name store.

MissingETBase::Types::bitmask_t & xAOD::MissingET_v1::f_source (  )  [inline, protected]

Returns reference to MET object source store.

double & xAOD::MissingET_v1::f_sumet (  )  [inline, protected]

Returns reference to $ \Sigma E_{\rm T} $ store.

const std::string & xAOD::MissingET_v1::name (  )  const [inline]

Identifier getters.

MET object name

Returns:
Reference to non-modifiable dataword storing the name of the MET object.
bool xAOD::MissingET_v1::operator!= ( const MissingET_v1 &  met  )  const [inline]

Inequality test.

Two MET objects are not equal when they do not have, within the precision defined in MissingETBase::Numerical::precision(), the same $ E_{\rm T}^{\rm miss} $ and the same $ \Sigma E_{\rm T} $.

Returns:
true if two MET objects are not equal.
xAOD::MissingET_v1 & xAOD::MissingET_v1::operator*= ( double  scale  )  [inline]

Applying a scale factor.

Returns:
Reference to self.
Parameters:
[in] scale scale factor to be applied to all MET components.

The data content of this MET object is updated as follows:

\begin{eqnarray*} p_{x}^{\rm miss} & \to & f \cdot p_{x}^{\rm miss} \\ p_{y}^{\rm miss} & \to & f \cdot p_{y}^{\rm miss} \\ \Sigma E_{\rm T} & \to & f \cdot \Sigma E_{\rm T} \end{eqnarray*}

Here $ (p_{x}^{\rm miss},p_{y}^{\rm miss},\Sigma E_{\rm T}) $ are the components of this object, and $ f $ is the scale factor.

xAOD::MissingET_v1 & xAOD::MissingET_v1::operator+= ( const MissingET_v1 &  met  )  [inline]

Add another MET object.

Returns:
Reference to self.
Parameters:
[in] met reference to non-modifiable MET object.

The data content of this MET object is updated with the components provided by the referenced MET object:

\begin{eqnarray*} p_{x}^{\rm miss} & \to & p_{x}^{\rm miss} + p_{x}^{{\rm miss}\prime} \\ p_{y}^{\rm miss} & \to & p_{y}^{\rm miss} + p_{y}^{{\rm miss}\prime} \\ \Sigma E_{\rm T} & \to & \Sigma E_{\rm T} + \Sigma E_{\rm miss}^{\prime} . \end{eqnarray*}

Here $ (p_{x}^{\rm miss},p_{y}^{\rm miss},\Sigma E_{\rm T}) $ are the components of this object, while $ (p_{x}^{{\rm miss}\prime},p_{y}^{{\rm miss}\prime},\Sigma E_{\rm T}^{\prime}) $ are the components of the added object.

xAOD::MissingET_v1 & xAOD::MissingET_v1::operator+= ( const IParticle *  particle  )  [inline]

Add particle kinematics to MET.

Returns:
Reference to (updated) self. The particle kinematics is added to MET.
xAOD::MissingET_v1 & xAOD::MissingET_v1::operator-= ( const MissingET_v1 &  met  )  [inline]

Subtract another MET object.

Returns:
Reference to self.
Parameters:
[in] met reference to non-modifiable MET object.

The data content of this MET object is updated with the components provided by the referenced MET object:

\begin{eqnarray*} p_{x}^{\rm miss} & \to & p_{x}^{\rm miss} - p_{x}^{{\rm miss}\prime} \\ p_{y}^{\rm miss} & \to & p_{y}^{\rm miss} - p_{y}^{{\rm miss}\prime} \\ \Sigma E_{\rm T} & \to & \Sigma E_{\rm T} - \Sigma E_{\rm miss}^{\prime} . \end{eqnarray*}

Here $ (p_{x}^{\rm miss},p_{y}^{\rm miss},\Sigma E_{\rm T}) $ are the components of this object, while $ (p_{x}^{{\rm miss}\prime},p_{y}^{{\rm miss}\prime},\Sigma E_{\rm T}^{\prime}) $ are the components of the subtracted object.

xAOD::MissingET_v1 & xAOD::MissingET_v1::operator-= ( const IParticle *  part  ) 

Remove particle kinematics to MET.

The particle kinematics is subtracted to the MET object This method updates the internal data stores. If each MET component needs a different scale, xAOD::MissingET_v1::add(double,double,double) can be used.

Returns:
Reference to (updated) self.
Parameters:
[in] particle pointer to the particle object

This method updates the internal data stores holding $ (p_{x},p_{y},\Sigma E_{\rm T}) $ like:

\begin{eqnarray*} p_{x}^{\rm miss} & \to & p_{x}^{\rm miss} + p_{x}^{\rm particle} \\ p_{y}^{\rm miss} & \to & p_{y}^{\rm miss} + p_{y}^{\rm particle} \\ \Sigma E_{\rm T} & \to & \Sigma E_{\rm T} - p_{\rm T}^{\rm particle} . \end{eqnarray*}

The particle momentum components subtracted from MET are $ p_{x}^{\rm particle} $, $ p_{y}^{\rm particle} $, and $ p_{\rm T}^{\rm particle} $.

xAOD::MissingET_v1 & xAOD::MissingET_v1::operator/= ( double  scale  )  [inline]

Dividing by a scale factor.

Returns:
Reference to self.
Parameters:
[in] scale scale factor to be applied to all MET components.

The data content of this MET object is updated as follows:

\begin{eqnarray*} p_{x}^{\rm miss} & \to & p_{x}^{\rm miss} / f \\ p_{y}^{\rm miss} & \to & p_{y}^{\rm miss} / f \\ \Sigma E_{\rm T} & \to & \Sigma E_{\rm T} / f \end{eqnarray*}

Here $ (p_{x}^{\rm miss},p_{y}^{\rm miss},\Sigma E_{\rm T}) $ are the components of this object, and $ f $ is the scale factor.

Note:
If $ f = 0 $, the rule implemented in MissingETBase::Numerical::divide(double,double) is applied to the results for each component.
bool xAOD::MissingET_v1::operator== ( const MissingET_v1 &  met  )  const [inline]

Equality test.

Two MET objects are equal when they have, within the precision defined in MissingETBase::Numerical::precision(), the same $ E_{\rm T}^{\rm miss} $ and the same $ \Sigma E_{\rm T} $.

Returns:
true if two MET objects are equal.
void xAOD::MissingET_v1::setMpx ( double  value  )  [inline]

Set the $ p_{x}^{\rm miss} $ component.

Parameters:
[in] value new value for component.
Note:
This is a true setter function. The previous stored value is replaced by the new value.
Warning:
This method only sets one MET component. It does not update any other data held by the MET object. Clients should use the xAOD::MissingET_v1::add methods for coherent update of all related data.
void xAOD::MissingET_v1::setMpy ( double  value  )  [inline]

Set the $ p_{y}^{\rm miss} $ component.

Parameters:
[in] value new value for component.
Note:
This is a true setter function. The previous stored value is replaced by the new value.
Warning:
This method only sets one MET component. It does not update any other data held by the MET object. Clients should use the xAOD::MissingET_v1::add methods for coherent update of all related data.

void xAOD::MissingET_v1::setName ( const std::string &  name  )  [inline]

Set the name of the MET object.

Parameters:
[in] name reference to non-modifiable dataword holding the desired name of the MET object.
Note:
This is a true setter function. The previous stored value is replaced by the new value.
void xAOD::MissingET_v1::setSource ( MissingETBase::Types::bitmask_t  src  )  [inline]

Set the source of the MET object.

Elements of the bitmasks and helpers interpreting them are given in the MissingETBase::Source structure.

Parameters:
[in] src bitmask of new source indicator
Note:
This is a true setter function. The previous stored value is replaced by the new value.
void xAOD::MissingET_v1::setSumet ( double  value  )  [inline]

Set $ \Sigma E_{\rm T} $.

Parameters:
[in] value new value for component.
Note:
This is a true setter function. The previous stored value is replaced by the new value.
Warning:
This method only sets one MET component. It does not update any other data held by the MET object. Clients should use the xAOD::MissingET_v1::add methods for coherent update of all related data.

MissingETBase::Types::bitmask_t xAOD::MissingET_v1::source (  )  const [inline]

MET object source tag.

Returns:
Bit mask characterizing the source of this MET term
The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on 1 Dec 2017 for RootCore Packages by  doxygen 1.6.1