#include <JetElement_v1.h>

Inheritance diagram for xAOD::JetElement_v1:

Collaboration diagram for xAOD::JetElement_v1:

Public Member Functions
	JetElement_v1 ()
float	phi () const
	get phi (note that for L1Calo phi runs from 0 to 2pi)
void	setPhi (float)
	set phi
float	eta () const
	get eta
void	setEta (float)
	set eta
unsigned int	key () const
	get key
void	setKey (unsigned int)
	set key
int	peak () const
	get peak
void	setPeak (int)
	set key
const std::vector< int > &	emEnergyVec () const
	get emEnergyVec - emEnergy for all time slices
void	setEmEnergyVec (const std::vector< int > &)
	set emEnergyVec - emEnergy for all time slices
const std::vector< int > &	hadEnergyVec () const
	get hadEnergyVec - hadEnergy for all time slices
void	setHadEnergyVec (const std::vector< int > &)
	set hadEnergyVec - hadEnergy for all time slices
const std::vector< int > &	emErrorVec () const
	get emErrorVec - emError for all time slices
void	setEmErrorVec (const std::vector< int > &)
	set emErrorVec - emError for all time slices
const std::vector< int > &	hadErrorVec () const
	get hadErrorVec - hadError for all time slices
void	setHadErrorVec (const std::vector< int > &)
	set hadErrorVec - hadError for all time slices
const std::vector< int > &	linkErrorVec () const
	get linkErrorVec - linkError for all time slices
void	setLinkErrorVec (const std::vector< int > &)
	set linkErrorVec - linkError for all time slices
void	addEnergy (int emEnergy, int hadEnergy)
	Add ET to triggered time slice.
void	addSlice (int slice, int emEnergy, int hadEnergy, int emError, int hadError, int linkError)
	Add ET values to specified slice.
int	emEnergy () const
	get emEnery for emEnergyVec[peak] - time slice that (hopefully) contains the collision
int	hadEnergy () const
	get hadEnery for hadEnergyVec[peak] - time slice that (hopefully) contains the collision
int	energy () const
	get total energy. returns emEnergy() + hadEnergy()
int	emSliceEnergy (int slice) const
	get emEnery for emEnergyVec[slice] - time slice for arbitary slice
int	hadSliceEnergy (int slice) const
	get hadEnery for hadEnergyVec[slice] - time slice for arbitary slice
int	sliceEnergy (int slice) const
	get total energy. returns emSliceEnergy(slice) + hadSliceEnergy(slice)
bool	isSaturated () const
	is JetElement saturated?
bool	isEmSaturated () const
	is EM component of JetElement saturated?
bool	isHadSaturated () const
	is Had component of JetElement saturated?
int	emError () const
	get emError for emErrorVec[peak] - time slice that (hopefully) contains the collision
int	hadError () const
	get hadError for hadErrorVec[peak] - time slice that (hopefully) contains the collision
int	linkError () const
	get linkError for linkErrorVec[peak] - time slice that (hopefully) contains the collision

Static Private Attributes
static const int	m_saturationThreshold = 1023
static const int	m_layerSaturationThreshold = 511

Detailed Description

Description of JetElement_v1.

Author: John Morris john..nosp@m.morr.nosp@m.is@ce.nosp@m.rn.c.nosp@m.h

Revision: 631127

Date: 2014-11-26 10:54:48 +0100 (Wed, 26 Nov 2014)

Definition at line 23 of file JetElement_v1.h.

Constructor & Destructor Documentation

◆ JetElement_v1()

xAOD::JetElement_v1::JetElement_v1 ( )

Definition at line 18 of file JetElement_v1.cxx.

                               :
    SG::AuxElement()
  {        
  }

Member Function Documentation

◆ addEnergy()

void xAOD::JetElement_v1::addEnergy	(	int	emEnergy,
		int	hadEnergy )

Add ET to triggered time slice.

EM Section

Calclate the modified energy if it is above saturation threshold, set it to the saturation threshold

Had Section

Calclate the modified energy if it is above saturation threshold, set it to the saturation threshold

Definition at line 33 of file JetElement_v1.cxx.

  {
    
    int modifiedEmEnergy = emEnergy() + emEnergyIn;
    if( modifiedEmEnergy > m_layerSaturationThreshold ){
      modifiedEmEnergy = m_layerSaturationThreshold;
    }
    
    // copy (I don't like this) the current Aux const data member vector to a non-const stack vector
    // modify the content of the stack vector and set it as the Aux data member
    std::vector<int> modifiedEmEnergyVec;
    const std::vector<int> currentEmEnergyVec = emEnergyVec();
    for(std::vector<int>::const_iterator i=currentEmEnergyVec.begin();i!=currentEmEnergyVec.end();++i){
      modifiedEmEnergyVec.push_back( (*i) );
    }
    modifiedEmEnergyVec[ peak() ] = modifiedEmEnergy;
    setEmEnergyVec( modifiedEmEnergyVec );
    
    
    
    int modifiedHadEnergy = hadEnergy() + hadEnergyIn;
    if( modifiedHadEnergy > m_layerSaturationThreshold ){
      modifiedEmEnergy = m_layerSaturationThreshold;
    }
    
    // copy (I don't like this) the current Aux const data member vector to a non-const stack vector
    // modify the content of the stack vector and set it as the Aux data member
    std::vector<int> modifiedHadEnergyVec;
    const std::vector<int> currentHadEnergyVec = hadEnergyVec();
    for(std::vector<int>::const_iterator i=currentHadEnergyVec.begin();i!=currentHadEnergyVec.end();++i){
      modifiedHadEnergyVec.push_back( (*i) );
    }
    modifiedHadEnergyVec[ peak() ] = modifiedHadEnergy;
    setHadEnergyVec( modifiedHadEnergyVec );    
    
    
  }

◆ addSlice()

void xAOD::JetElement_v1::addSlice	(	int	slice,
		int	emEnergy,
		int	hadEnergy,
		int	emError,
		int	hadError,
		int	linkError )

Add ET values to specified slice.

This functions works just like addEnergy, it's just got more in it

Definition at line 78 of file JetElement_v1.cxx.

  {
 
    // EM Energy
    int modifiedEmEnergy = emSliceEnergy( slice ) + emEnergyIn;
    if( modifiedEmEnergy > m_layerSaturationThreshold ){
      modifiedEmEnergy = m_layerSaturationThreshold;
    }   
    std::vector<int> modifiedEmEnergyVec;
    const std::vector<int> currentEmEnergyVec = emEnergyVec();
    for(std::vector<int>::const_iterator i=currentEmEnergyVec.begin();i!=currentEmEnergyVec.end();++i){
      modifiedEmEnergyVec.push_back( (*i) );
    }
    modifiedEmEnergyVec[ slice ] = modifiedEmEnergy;
    setEmEnergyVec( modifiedEmEnergyVec ); 
    
    // Had Energy
    int modifiedHadEnergy = hadSliceEnergy( slice ) + hadEnergyIn;
    if( modifiedHadEnergy > m_layerSaturationThreshold ){
      modifiedEmEnergy = m_layerSaturationThreshold;
    }
    std::vector<int> modifiedHadEnergyVec;
    const std::vector<int> currentHadEnergyVec = hadEnergyVec();
    for(std::vector<int>::const_iterator i=currentHadEnergyVec.begin();i!=currentHadEnergyVec.end();++i){
      modifiedHadEnergyVec.push_back( (*i) );
    }
    modifiedHadEnergyVec[ slice ] = modifiedHadEnergy;
    setHadEnergyVec( modifiedHadEnergyVec );      
    
    // EM Error
    int modifiedEmError = emErrorVec()[ slice ] + emErrorIn;
    std::vector<int> modifiedEmErrorVec;
    const std::vector<int> currentEmErrorVec = emErrorVec();
    for(std::vector<int>::const_iterator i=currentEmErrorVec.begin();i!=currentEmErrorVec.end();++i){
      modifiedEmErrorVec.push_back( (*i) );
    }
    modifiedEmErrorVec[ slice ] = modifiedEmError;
    setEmErrorVec( modifiedEmErrorVec );  
    
    // Had Error
    int modifiedHadError = hadErrorVec()[ slice ] + hadErrorIn;
    std::vector<int> modifiedHadErrorVec;
    const std::vector<int> currentHadErrorVec = hadErrorVec();
    for(std::vector<int>::const_iterator i=currentHadErrorVec.begin();i!=currentHadErrorVec.end();++i){
      modifiedHadErrorVec.push_back( (*i) );
    }
    modifiedHadErrorVec[ slice ] = modifiedHadError;
    setHadErrorVec( modifiedHadErrorVec );   
    
    // Link Error
    int modifiedLinkError = linkErrorVec()[ slice ] + linkErrorIn;
    std::vector<int> modifiedLinkErrorVec;
    const std::vector<int> currentLinkErrorVec = linkErrorVec();
    for(std::vector<int>::const_iterator i=currentLinkErrorVec.begin();i!=currentLinkErrorVec.end();++i){
      modifiedLinkErrorVec.push_back( (*i) );
    }
    modifiedLinkErrorVec[ slice ] = modifiedLinkError;
    setLinkErrorVec( modifiedLinkErrorVec );      
    
    
  }

◆ emEnergy()

int xAOD::JetElement_v1::emEnergy ( ) const

get emEnery for emEnergyVec[peak] - time slice that (hopefully) contains the collision

Definition at line 141 of file JetElement_v1.cxx.

  {
    if( emEnergyVec()[ peak() ] < m_layerSaturationThreshold) {
      return emEnergyVec()[ peak() ];
    }
    return m_layerSaturationThreshold;    
  }

◆ emEnergyVec()

const std::vector< int > & xAOD::JetElement_v1::emEnergyVec ( ) const

get emEnergyVec - emEnergy for all time slices

◆ emError()

int xAOD::JetElement_v1::emError ( ) const

get emError for emErrorVec[peak] - time slice that (hopefully) contains the collision

Definition at line 216 of file JetElement_v1.cxx.

  {
    return emErrorVec()[ peak() ];
  }

◆ emErrorVec()

const std::vector< int > & xAOD::JetElement_v1::emErrorVec ( ) const

get emErrorVec - emError for all time slices

◆ emSliceEnergy()

int xAOD::JetElement_v1::emSliceEnergy ( int slice ) const

get emEnery for emEnergyVec[slice] - time slice for arbitary slice

Definition at line 168 of file JetElement_v1.cxx.

  {
    if( slice >= 0 && slice < (int)emEnergyVec().size() ) {
      if( emEnergyVec()[ slice ] < m_layerSaturationThreshold ) {
        return emEnergyVec()[ slice ];
      }
      return m_layerSaturationThreshold;
    }
    return 0;    
  }

◆ energy()

int xAOD::JetElement_v1::energy ( ) const

get total energy. returns emEnergy() + hadEnergy()

Definition at line 157 of file JetElement_v1.cxx.

  {
    
    if( ( emEnergy()  >= m_layerSaturationThreshold ) ||
        ( hadEnergy() >= m_layerSaturationThreshold ) ||
        ( ( emEnergy() + hadEnergy() ) >= m_saturationThreshold ) ){
          return m_saturationThreshold;
    }
    return emEnergy() + hadEnergy();  
  }

◆ eta()

float xAOD::JetElement_v1::eta ( ) const

get eta

◆ hadEnergy()

int xAOD::JetElement_v1::hadEnergy ( ) const

get hadEnery for hadEnergyVec[peak] - time slice that (hopefully) contains the collision

Definition at line 149 of file JetElement_v1.cxx.

  {
    if( hadEnergyVec()[ peak() ] < m_layerSaturationThreshold) {
      return hadEnergyVec()[ peak() ];
    }
    return m_layerSaturationThreshold;      
  }

◆ hadEnergyVec()

const std::vector< int > & xAOD::JetElement_v1::hadEnergyVec ( ) const

get hadEnergyVec - hadEnergy for all time slices

◆ hadError()

int xAOD::JetElement_v1::hadError ( ) const

get hadError for hadErrorVec[peak] - time slice that (hopefully) contains the collision

Definition at line 221 of file JetElement_v1.cxx.

  {
    return hadErrorVec()[ peak() ];
  }

◆ hadErrorVec()

const std::vector< int > & xAOD::JetElement_v1::hadErrorVec ( ) const

get hadErrorVec - hadError for all time slices

◆ hadSliceEnergy()

int xAOD::JetElement_v1::hadSliceEnergy ( int slice ) const

get hadEnery for hadEnergyVec[slice] - time slice for arbitary slice

Definition at line 179 of file JetElement_v1.cxx.

  {
    if( slice >= 0 && slice < (int)hadEnergyVec().size() ) {
      if( hadEnergyVec()[ slice ] < m_layerSaturationThreshold ) {
        return hadEnergyVec()[ slice ];
      }
      return m_layerSaturationThreshold;
    }
    return 0;     
  }

◆ isEmSaturated()

bool xAOD::JetElement_v1::isEmSaturated ( ) const

is EM component of JetElement saturated?

Definition at line 206 of file JetElement_v1.cxx.

  {
    return emEnergy() == m_layerSaturationThreshold;
  }

◆ isHadSaturated()

bool xAOD::JetElement_v1::isHadSaturated ( ) const

is Had component of JetElement saturated?

Definition at line 211 of file JetElement_v1.cxx.

  {
    return hadEnergy() == m_layerSaturationThreshold;    
  }

◆ isSaturated()

bool xAOD::JetElement_v1::isSaturated ( ) const

is JetElement saturated?

Definition at line 201 of file JetElement_v1.cxx.

  {
    return energy() == m_saturationThreshold;
  }

◆ key()

unsigned int xAOD::JetElement_v1::key ( ) const

get key

◆ linkError()

int xAOD::JetElement_v1::linkError ( ) const

get linkError for linkErrorVec[peak] - time slice that (hopefully) contains the collision

Definition at line 226 of file JetElement_v1.cxx.

  {
    return linkErrorVec()[ peak() ];
  }

◆ linkErrorVec()

const std::vector< int > & xAOD::JetElement_v1::linkErrorVec ( ) const

get linkErrorVec - linkError for all time slices

◆ peak()

int xAOD::JetElement_v1::peak ( ) const

get peak

◆ phi()

float xAOD::JetElement_v1::phi ( ) const

get phi (note that for L1Calo phi runs from 0 to 2pi)

◆ setEmEnergyVec()

void xAOD::JetElement_v1::setEmEnergyVec ( const std::vector< int > & )

set emEnergyVec - emEnergy for all time slices

◆ setEmErrorVec()

void xAOD::JetElement_v1::setEmErrorVec ( const std::vector< int > & )

set emErrorVec - emError for all time slices

◆ setEta()

void xAOD::JetElement_v1::setEta ( float )

set eta

◆ setHadEnergyVec()

void xAOD::JetElement_v1::setHadEnergyVec ( const std::vector< int > & )

set hadEnergyVec - hadEnergy for all time slices

◆ setHadErrorVec()

void xAOD::JetElement_v1::setHadErrorVec ( const std::vector< int > & )

set hadErrorVec - hadError for all time slices

◆ setKey()

void xAOD::JetElement_v1::setKey ( unsigned int )

set key

◆ setLinkErrorVec()

void xAOD::JetElement_v1::setLinkErrorVec ( const std::vector< int > & )

set linkErrorVec - linkError for all time slices

◆ setPeak()

void xAOD::JetElement_v1::setPeak ( int )

set key

◆ setPhi()

void xAOD::JetElement_v1::setPhi ( float )

set phi

◆ sliceEnergy()

int xAOD::JetElement_v1::sliceEnergy ( int slice ) const

get total energy. returns emSliceEnergy(slice) + hadSliceEnergy(slice)

Definition at line 190 of file JetElement_v1.cxx.

  {
    if( ( emSliceEnergy(slice)  >= m_layerSaturationThreshold ) ||
        ( hadSliceEnergy(slice) >= m_layerSaturationThreshold ) ||
        ( ( emSliceEnergy(slice) + hadSliceEnergy(slice) ) >= m_saturationThreshold ) ){
          return m_saturationThreshold;
       }
    return emSliceEnergy(slice) + hadSliceEnergy(slice); 
  }

Member Data Documentation

◆ m_layerSaturationThreshold

const int xAOD::JetElement_v1::m_layerSaturationThreshold = 511

staticprivate

Definition at line 108 of file JetElement_v1.h.

◆ m_saturationThreshold

const int xAOD::JetElement_v1::m_saturationThreshold = 1023